inheritance - constructor

Code:

class Vector2_1
{
protected:
	double a, b;
public:
	Vector2_1() {a=0; b=0;}
	Vector2_1(double vec1, double vec2):a(vec1), b(vec2) {}
	void SetSpecificValue(double value, int pos);
	double GetSpecificValue(int pos) const;
	virtual void print() {cout<<endl<<"["<<a<<" "<<b<<"]T"<<endl;}
};


class Vector1_2:public Vector2_1
{
public:
	Vector1_2 operator * (const Matrix2_2&) const;
	void print() {cout<<endl<<"["<<a<<" "<<b<<"]<<endl;} //The problematic line
};

Two problems:
1) For some reason it's like there is no inheritance between Vector1_2 from Vector2_1.
I can't write
Vector1_2 vec2(2,3);
It says there is no such overloaded function...

2) Adding the print() at the daughter class results in a large collection of errors, I guess from something related to the first point.

Thank you.

All classes need their own constructor. The compiler will automatically call the default constructor of the base-class, but the derived class needs to have a constructor.

Your print function in the derived class has "] without an end quote, which can indeed lead to all sorts of errors.

--
Mats

Constructors are not inherited.

Thank you very much

I think it makes more sense to think in that the base class's constructor is only used to construct the base class itself, and not the derived class. When you type Vector1_2 vec2(2, 3), it tries to find a constructor for Vector1_2 that takes two ints and will not look in the base class.
All functions are inherited (though I dunno about constructors), even if private, just... they can't be accessed if they're private.

Originally Posted by laserlight

Constructors are not inherited.

Depends how you look at it... The constructor is still there, and in fact must be there, so the derived class's constructor can call it first before constructing itself. But the user of the class has no way to access it.

Originally Posted by brewbuck

Depends how you look at it... The constructor is still there, and in fact must be there, so the derived class's constructor can call it first before constructing itself. But the user of the class has no way to access it.

So, what's the difference?

Code:

Vector1_2(double vec1, double vec2) {Vector2_1(vec1,vec2);}
Vector1_2(double vec1, double vec2) {a=vec1; b=vec2;}

The first one initializes a and b using the default constructor of the base class even though I called the overloaded one...
The second form acts well...

Why?

The derived class can access the base class's constructor, since it's just a function of the base class, but the code outside the class can't construct an object through the base class's constructor. It can only call a derived constructor when creating the object.

You could, of course, explicitly call the base class's constructor after you've created the object, but what's the point?

So, what's the difference?

One can argue that constructors are inherited since the derived class constructors can use them. One could argue that they are not inherited since, being special member functions, constructors are invoked via special syntax, and with this kind of syntax it is impossible, regardless of public/protected/private access, for the user of the class (or indeed member functions of the class other than the constructors) to access base class constructors directly.

The first one initializes a and b using the default constructor of the base class even though I called the overloaded one...

You should be using an initialisation list:

Code:

Vector1_2(double vec1, double vec2) : Vector2_1(vec1,vec2) {}
// or
Vector1_2(double vec1, double vec2) : a(vec1), b(vec2) {}

The first one initializes a temp object which immediately gets thrown away. It does nothing to initialize the base class at all, it does not touch the base Vector2_1 object at all. What you probably want is to use the initializer list for the 1st Vector1_2 constructor to construct the base Vector2_1 object using those parameters:

Code:

Vector1_2(double vec1, double vec2) : Vector2_1(vec1,vec2) {}

Code:

class Vector2_1
{
protected:
	double a, b;
public:
	Vector2_1() {a=0; b=0;}
	Vector2_1(double vec1, double vec2):a(vec1), b(vec2) {}
	void SetSpecificValue(double value, int pos);
	double GetSpecificValue(int pos) const;
	virtual void print() {cout<<endl<<"["<<a<<" "<<b<<"]T"<<endl;}
	Vector1_2 transpose() {return Vector1_2(a,b);}  //the problem
	Vector2_1 operator / (const double& C);
};



class Vector1_2:public Vector2_1
{
public:
	Vector1_2() {Vector2_1();}
	//Vector1_2(double vec1, double vec2) {Vector2_1(vec1,vec2);}
	Vector1_2(double vec1, double vec2) {a=vec1; b=vec2;}
	Vector1_2 operator * (const Matrix2_2&) const;
	void print() {cout<<endl<<"["<<a<<" "<<b<<"]"<<endl;}
	Vector2_1 transpose() {return Vector2_1(a,b);}
};

error C2501: 'Vector2_1::Vector1_2' : missing storage-class or type specifiers
error C2146: syntax error : missing ';' before identifier 'transpose'
error C2146: syntax error : missing ';' before identifier 'transpose'
error C2501: 'Vector2_1::Vector1_2' : missing storage-class or type specifiers

I have a function in the base class that generates an instance of the derived class. I assume that the problem is that the base class doesn't know the derived class because it is beneath it, therefore, I tried to declare the classes at the head of the header

Code:

class Vector2_1;
class Matrix2_2;
class Vector1_2:class Vector2_1;

This results in a massive amount of errors.

This is not possible.
Vector1_2 needs to be defined before Vector2_1 for this to work because you're returning a new object of type Vector1_2, thus it needs to call the constructor.

Originally Posted by Elysia

This is not possible.
Vector1_2 needs to be defined before Vector2_1 for this to work because you're returning a new object of type Vector1_2, thus it needs to call the constructor.

It's not working and I guess because the derived class, when placed on top, don't know the base class, and declaring the base class in the beginning doesn't help too.

Indeed. The solution to such a problem is to rethink your design or return pointers so it doesn't need to call the constructor in the header.

I'm sorry for not being very familiar with these things but...

What is the difference between Vector1_2 and Vector2_1 and why is one inherited from the other and not, perhaps, the other way round.? (Especially seeing that transpose should return the other for both.)

As I see the only difference is that one prints "T" in addition to the common things, and methods are rather randomly distributed between the two. Couldn't you put a bool in there to show that it is or isn't transposed? (Does it even matter if it is transposed? Wouldn't it be up to the user to decide what the vector represents?)