Printable View
friend ostream& operator<<(ostream& output, const Matrix& matrix)
Error 2 error C2662: 'Matrix<T>::YDim' : cannot convert 'this' pointer from 'const Matrix<T>' to 'Matrix<T> &'
I seem to get the same error for all of the functions I'm defining with a const Matrix& matrix, but when I remove the const it works fine.
Thanks in advance!
Well what is the Matrix class? Post the class declaration? Is this a template class? Someone might recognize the error and have an epiphany but it is always better to post enough code so that other people can drag and drop the text into a file and compile it themselves.
...
Most likely cause is YDim needs to be declared const:
Matrix<T>::YDim() const
{
}
Sorry about that....
template <typename T>
class Matrix
{
private:
T** mMatrix;
T mValue;
public:
Matrix(size_t pRows, size_t pCols, const T& value)
{
size_t i, j; // General purpose loop variables
mValue = value;
mMatrix = new T* [pRows+1]; ; // Allocate rows
for(i=0; i<pRows; i++)
mMatrix[i] = new T[pCols+1]; // Allocate columns
mMatrix[i] = new T[1]; // Allocate sentinel row
// initialize mMatrix
for(i=0; i<pRows; i++)
{
size_t j;
for(j=0; j<pCols; j++)
mMatrix[i][j] = value; // initialize column with value
mMatrix[i][j] = (T) -1; // Add sentinel to end of column
}
mMatrix[i][0] = (T) -1; // Add sentinel to last row
}
~Matrix() { Destroy(); }
void Destroy()
{
for(size_t y=0; y<YDim(); y++)
{
delete mMatrix[y];
mMatrix[y]=0;
}
delete mMatrix;
mMatrix=0;
}
size_t& YDim()
{
size_t i=-1; // General purpose loop variables
if(mMatrix!=0)
for(i=0; mMatrix[i]!=0;i++)
if(mMatrix[i][0]== (T) -1) break;
return i;
}
size_t& XDim()
{
size_t j=-1; // General purpose loop variables
if(YDim()>0)
for(j=0; mMatrix[0][j] != (T) -1; j++);
return j;
}
T operator()(size_t row, size_t col)
{
return mMatrix[row][col];
}
bool ResetRow(size_t row)
{
return ResetRowTo(row, mValue);
}
bool ResetRowTo(size_t row, T value)
{
if(YDim()!=-1 && row<YDim())
{
for(size_t j=0; mMatrix[row][j] != (T) -1; j++)
mMatrix[row][j] = value;
return 1;
}
else
return 0;
}
friend ostream& operator<<(ostream& output, Matrix& matrix)
{
for(size_t y=0; y<matrix.YDim(); y++)
{
for(size_t x=0; x<matrix.XDim(); x++)
{
cout << matrix(y,x) << " ";
}
cout << endl;
}
return output;
}
};
If the function accepts 'matrix' as a const reference then it is not allowed to modify it. XDim & YDim members are not 'const' and therefore are not allowed to be called here, as they do not promise not to change the class.
please use [code][/code] tags when posting code.
You have a number of problems here. Remove the ampersand highlighted in bold since you are attempting to reference a function local variable that is popped of the stack when the function returns (this constitutes undefined behaviour), therefore you should return by value.
Also make the function into a const function i.e.Code:size_t& YDim()
{
size_t i=-1; // General purpose loop variables
if(mMatrix!=0)
for(i=0; mMatrix[i]!=0;i++)
if(mMatrix[i][0]== (T) -1) break;
return i;
}
Repeat the above two steps for XDim.Code:size_t YDim() const
{
size_t i=-1; // General purpose loop variables
if(mMatrix!=0)
for(i=0; mMatrix[i]!=0;i++)
if(mMatrix[i][0]== (T) -1) break;
return i;
}
Also, you should modify your operator() function by adding the ampersand highlighted in bold since users of your class would intitively expect it to return by reference, so they can modify the value in the array:
You also need to add a const function version of the above:Code:T& operator()(size_t row, size_t col)
{
return mMatrix[row][col];
}
Note that the return of the const version purposely returns by value, alternatively you can return by const reference.Code:T operator()(size_t row, size_t col) const
{
return mMatrix[row][col];
}
I agreed with 0xC0000005 when I read his post but this code compiled fine for me even without declaring the functions const. That is odd. I didn't expect this to compile. I'm using a green hills c++ compiler.
Code:template <typename T>
class Matrix
{
private:
T** mMatrix;
T mValue;
public:
Matrix(size_t pRows, size_t pCols, const T& value)
{
size_t i, j; // General purpose loop variables
mValue = value;
mMatrix = new T* [pRows+1]; ; // Allocate rows
for(i=0; i<pRows; i++)
mMatrix[i] = new T[pCols+1]; // Allocate columns
mMatrix[i] = new T[1]; // Allocate sentinel row
// initialize mMatrix
for(i=0; i<pRows; i++)
{
size_t j;
for(j=0; j<pCols; j++)
mMatrix[i][j] = value; // initialize column with value
mMatrix[i][j] = (T) -1; // Add sentinel to end of column
}
mMatrix[i][0] = (T) -1; // Add sentinel to last row
}
~Matrix() { Destroy(); }
void Destroy()
{
for(size_t y=0; y<YDim(); y++)
{
delete mMatrix[y];
mMatrix[y]=0;
}
delete mMatrix;
mMatrix=0;
}
size_t& YDim()
{
size_t i=-1; // General purpose loop variables
if(mMatrix!=0)
for(i=0; mMatrix[i]!=0;i++)
if(mMatrix[i][0]== (T) -1) break;
return i;
}
size_t& XDim()
{
size_t j=-1; // General purpose loop variables
if(YDim()>0)
for(j=0; mMatrix[0][j] != (T) -1; j++);
return j;
}
T operator()(size_t row, size_t col)
{
return mMatrix[row][col];
}
bool ResetRow(size_t row)
{
return ResetRowTo(row, mValue);
}
bool ResetRowTo(size_t row, T value)
{
if(YDim()!=-1 && row<YDim())
{
for(size_t j=0; mMatrix[row][j] != (T) -1; j++)
mMatrix[row][j] = value;
return 1;
}
else
return 0;
}
friend ostream& operator<<(ostream& output, const Matrix& matrix)
{
for(size_t y=0; y<matrix.YDim(); y++)
{
for(size_t x=0; x<matrix.XDim(); x++)
{
cout << matrix(y,x) << " ";
}
cout << endl;
}
return output;
}
};
In addition to my above comments, the lack of std:: before ostream in your operator<< function suggests that you are writing using namespace std; in your header file, and you shouldn't do this in your header file, since you may cause namespace clashes in any other code that is included in your compilation.
You seem to have some issues with your loop variables. You declare a loop variable j in your constructor, but do not use it, prefering to declare a second local j inside your initialise matrix for loop. You should get into the habit of initialising your variables.
Finally, the following code found in your constructor:
Once your for loop finishes, you fail to increment i before assigning a new memory allocation to [I]mMatrix - this constitutes a memory leak.Code:for(i=0; i<pRows; i++)
mMatrix[i] = new T[pCols+1]; // Allocate columns
mMatrix[i] = new T[1]; // Allocate sentinel row
You could change the above to
Code:for(i=0; i<pRows; i++)
mMatrix[i] = new T[pCols+1]; // Allocate columns
mMatrix[++i] = new T[1]; // Allocate sentinel row
Perhaps you forgot to print the matrix e.g? :Quote:
Originally Posted by kempofighter
If you don't use the operator<< function, the compiler is allowed to exclude it from the compilation.Code:Matrix<int> m(5,5,0);
std::cout << m << std::endl;
Good point, I tried exactly that but got a compiler error. I've never overloaded the << operator before so I didn't understand why *that* didn't compile.Quote:
Originally Posted by PredicateNormative
I thought that the overloaded << was supposed to make that work. If I comment out the cout, the class declaration compiles (for the reason your are specifying most likely). But if I try to use the stream operator as you suggest I get this other error instead. Also, in the previous block of code that I posted I changed the input arg to non-const just to see if that line in the main function would compile that uses the overloaded <<.Code:int main ()
{
Matrix<int> m(5,5,0);
std::cout << m << std::endl;
return 0;
}
error #349: no operator "<<" matches these operands
operand types are: std::ostream << Matrix<int>
std::cout << m << std::endl;
Good point on the other comments. I saw similar things and the class decl does produce quite a few warnings but you have already pointed those things out. I wonder how you are able to compile that simple main function but I am not. Weird.
What line is it complaining about? Have you made sure that all standard objects have std:: before them, or have you used the non-ideal solution by adding using namespace std?
If you have done the above, then thinking about it, the problem is probably that technically:
is incorrect, and should beCode:template <typename T>
class Matrix
{
//...
friend ostream& operator<<(ostream& output, const Matrix& matrix)
{
for(size_t y=0; y<matrix.YDim(); y++)
{
for(size_t x=0; x<matrix.XDim(); x++)
{
std::cout << matrix(y,x) << " ";
}
std::cout << std::endl;
}
return output;
}
};
Code:template <typename T>
class Matrix
{
//...
template <typename U>
friend std::ostream& operator<<(std::ostream& output, const Matrix<U>& matrix);
};
template <typename U>
std::ostream& operator<<(std::ostream& output, const Matrix<U>& matrix)
{
for(size_t y=0; y<matrix.YDim(); y++)
{
for(size_t x=0; x<matrix.XDim(); x++)
{
std::cout << matrix(y,x) << " ";
}
std::cout << std::endl;
}
return output;
}
Thanks predicate, I was wondering about that declaration. However, the compiler error didn't change at all. Then I noticed something awfully strange about that overloaded << operator function. Something about it isn't correct.
The OP defined the function within the class which is incorrect. It needs to be declared as a friend but defined globally.
Also, the OP uses cout within the definition. That is also wrong. He needs to be doing it like this:
Well anyway, making those fixes seemed to work. The program compiled and printed a matrix full of zeroes. There are other warnings and problems with the program but at least those changes allowed the stream operator to work.Code:template <typename T>
class Matrix
{
// ... declaration of class
// declare the globally defined function to be a friend but don't define it
// in the class. Actually i don't think that this is necessary since the
// function uses Matrix's public interface but this is the pattern I see
// when studying existing code. I guess that this is done so that the
// function definition can directly access private/protected members.
template <typename T>
friend ostream& operator<<(ostream& output, Matrix<T>& matrix);
};
// (U) Define the function globally
template <typename T>
ostream& operator<<(ostream& output, Matrix<T>& matrix)
{
for(size_t y=0; y<matrix.YDim(); y++)
{
for(size_t x=0; x<matrix.XDim(); x++)
{
// (U) Stream to output not cout
output << matrix(y,x) << " ";
}
// (U) Stream to output not cout
output << std::endl;
}
return output;
}
Perhaps you should re-read the end of post #13;)
That is a good observation. The rule of thumb is to prefer non-member non-friend functions: GotW #84: Monoliths "Unstrung".Quote:
Originally Posted by kempofighter
That's not actually true. Friend functions can be defined within the class and, in the case of templates, can make the code easier to write. I had such a scenario where I was overloading various operators for a templated class (+-<). Defining the operators outside of the class caused problems that required extra code to get the normal operator functionality (I can't remember what the code was exactly). Defining the functions within the class was much simpler.Quote:
The OP defined the function within the class which is incorrect. It needs to be declared as a friend but defined globally.
EDIT : I've been trying to remember how to reproduce the problem, but it was a long time ago. :confused:
I know I'm stating the obvious, and I'm certainly not disagreeing with you, but although the standard specifies you can do this, you can only do it if the compiler supports it, and some don't. For this reason, and it is my preference, I tend to separate the declaration and definition.Quote:
Originally Posted by JohnW@Wessex
Also, I would have thought that for templated classes, the friend function should really have it's own template definition and not assume to inherit the class one. The reason being that if the friend function is extracted out of the class, it will need a template definition that matches that of the declaration, and that, as far as I am aware, needs to be an explicit template definition, and not one that is implied from the class template definition.
For example, the following does not compile, because, due to the lack of a function template definition on the function declaration it fails to associate the friend declaration with global definition.
Where as adding an explicit function template definition fixes the association issue...Code:template<typename T>
class MyClass
{
public:
MyClass(T val)
:val_(val)
,name_("MyClass")
{}
friend std::ostream& operator<<(std::ostream& o, const MyClass<T>& m);
private:
T val_;
std::string name_;
};
template<typename T>
std::ostream& operator<<(std::ostream& o, const MyClass<T>& m)
{
o << m.name_ << " holds the value " << m.val_ << std::endl;
return o;
}
Now I realise that when you define a template function in the class, its declaration is also its definition and therefore there are no problems associating the two, but somehow:Code:template<typename T>
class MyClass
{
public:
MyClass(T val)
:val_(val)
,name_("MyClass")
{}
template<typename U>
friend std::ostream& operator<<(std::ostream& o, const MyClass<U>& m);
private:
T val_;
std::string name_;
};
template<typename U>
std::ostream& operator<<(std::ostream& o, const MyClass<U>& m)
{
o << m.name_ << " holds the value " << m.val_ << std::endl;
return o;
}
doesn't feel right - but I can't put my finger on the reason why. If I was forced to write the definition inside the class, I would much prefer to write:Code:template<typename T>
class MyClass
{
public:
MyClass(T val)
:val_(val)
,name_("MyClass")
{}
friend std::ostream& operator<<(std::ostream& o, const MyClass<T>& m)
{
o << m.name_ << " holds the value " << m.val_ << std::endl;
return o;
}
private:
T val_;
std::string name_;
};
Code:template<typename T>
class MyClass
{
public:
MyClass(T val)
:val_(val)
,name_("MyClass")
{}
template<typename U>
friend std::ostream& operator<<(std::ostream& o, const MyClass<U>& m)
{
o << m.name_ << " holds the value " << m.val_ << std::endl;
return o;
}
private:
T val_;
std::string name_;
};
A very good observation... and I completely missed it.:mad:Quote:
Originally Posted by laserlight
Am I missing something?? :confused::confused:Quote:
Originally Posted by PredicateNormative
If the compiler states something is legal, and the compiler will not allow it, isn't that prima facia evidence that you have a non-conformant compiler????
(I admit I have not checked the wording of the specificiation)
No you're not missing anything, you are correct, the result is that if it isn't supported that the compiler is non-standard.