C++ explicit copy constructor? - c++

Question

I've hit a wall concerning this explicit copy constructor issue. I've been writing a class to figure things out:
#include <iostream>
template<class T>
class Mat
{
private:
T data;
public:
void set(T value)
{
data = value;
}
Mat()
: data(T(0))
{
}
explicit Mat(const Mat& another)
{
*this = another;
}
Mat& operator=(const Mat& another)
{
data = another.data;
return *this;
}
template<class U>
explicit operator Mat<U>()
{
Mat<U> result;
result.set(static_cast<U>(data));
return result;
}
void print()
{
std::cout << data << std::endl;
}
};
int main()
{
Mat< double > d1;
d1.set(3.14159);
Mat< int > i1(static_cast<Mat<int>>(d1));
d1.print();
i1.print();
std::cin.sync();
std::cin.ignore();
return 0;
}
I want my copy constructor to take only explicitly converted instances of another object, so I declared it explicit, but now I get the error error "C2558: class 'Mat' : no copy constructor available or copy constructor is declared 'explicit'", even though I made an explicit cast:
static_cast<Mat<int>>(d1)
I've declared the copy constructor explicit because I want this to be illegal:
Mat<float> a;
Mat<int> b(a);
While, I would like the following to remain legal:
Mat<float> a;
Mat<int> b(static_cast<Mat<int>>(a));
EDIT: I've been tinkering with this concepts trying to define exactly what I want to get, and I seem to get some funny results:
#include <iostream>
class MatB
{
private:
float data;
public:
MatB()
:data(0.0f)
{
}
void set(float value)
{
data = value;
}
float getData() const
{
return data;
}
void print()
{
std::cout << data << std::endl;
}
};
class MatA
{
private:
double data;
public:
MatA()
:data(0.0)
{
}
void set(double value)
{
data = value;
}
double getData() const
{
return data;
}
explicit operator MatB()
{
MatB temp;
temp.set(static_cast<float>(getData()));
return temp;
}
void print()
{
std::cout << data << std::endl;
}
};
class MatC
{
private:
int data;
public:
MatC()
:data(0)
{
}
explicit MatC(const MatB& in)
:data(static_cast<int>(in.getData()))
{
}
void print()
{
std::cout << data << std::endl;
}
};
int main()
{
MatA someA;
someA.set(3.14159);
MatC constructCFromA(someA);
someA.print();
constructCFromA.print();
std::cin.sync();
std::cin.ignore();
return 0;
}
In this example, constructCFromA(someA) shouldn't compile (imo) - even the linker marks it as an error(VS2013), still it compiles just fine... I am not sure whether my understanding of 'explicit' is incorrect, whether the IDE marks it as an error incorrectly, or the compiler compiles it even though it shouldn't. I thought I would need to do something like this:
constructCFromA(static_cast<MatB>(someA));
The IDE seems to agree with me, but the compiler doesn't. I must say I am pretty confused.
EDIT2:
Never mind, in Ideone it doesn't compile, so I guess MS are to blame.
I think the 2nd code illustrates well the behaviour I want to get. Basically make non-explicit conversions at initialization and assignment illegal. It seems however, that making the copy constructor explicit has various "side-effects".

Answer 1

The line where you did the explicit cast is not a problem. The problem that causes the compiling issue is on the line where you return Mat<U> by value:
template<class U>
explicit operator Mat<U>()
{
Mat<U> result;
result.set(static_cast<U>(data));
return result; // <<== This line requires a copy constructor to be defined
}
That is why when you remove explicit before the copy ctor, your code works just fine.

Answer 2

here's another version that will pass your unit test without the need for a conversion operator to T:
template<class T>
class Mat
{
private:
T data;
public:
void set(T value)
{
data = value;
}
// default constructor
Mat()
: data(T(0))
{
}
// construct from data type
explicit Mat(T dat)
: data(dat)
{}
// construct from any compatible Mat
template<class U>
explicit Mat(const Mat<U>& another)
: data(static_cast<T>(another.get_data()))
{}
// assign from any compatible Mat
template<class U>
Mat& operator=(const Mat<U>& another)
{
data = static_cast<T>(another.get_data());
return *this;
}
// provide a means to access data from unrelated Mat
const T& get_data() const { return data; }
void print()
{
std::cout << data << std::endl;
}
};