Ereditarietà e costruttori in C++

[progC__]

...Un grande saluto a tutti gli utenti del forum...qualcuno potrebbe darmi qualche spiegazione sul come ereditare i costruttori da una classe base?
...praticamente devo creare una nuova classe (vector) che erediti la classe point e quindi : class vector : public point{.....quello che non riesco a capire e su come ereditare i costruttori...dato che l'inizializzazione dovrà essere uguale a quella fatta dalla classe base...non riesco a capire


#include <math.h>
#include <iostream.h>
class point{
private:
//dichiarazione oggetti coordinate
double _x,_y,_z;
int dim;
public:
//inizializzazione oggetti mediante point
point(){
_x = 0;
_y = 0;
_z = 0;
}

//funzione crea punto 3D
point (const double x, const double y, const double z)
{
_x = x;
_y = y;
_z = z;
dim = 3;
}

//metodi
//funzioni inline
//ritorna la coordinata _x
double getx ()
{
return _x;
}
//ritorna la coordinata _y
double gety()
{
return _y;
}
//ritorna la coordinata _z
double getz()
{
return _z;
}
int getdim()
{
return dim;
}

//funzioni assegna valori coordinata
void setx(const double val)
{
_x = val;
}
void sety (const double val)
{
_y = val;
}
void setz (const double val)
{
_z = val;
}
void setdim (const int val)
{
dim = val;
}
};

//definizione classe derivata vettore di tipo public
class vector : public point{
................
public:


};

[jappilas]

class point
{ 
private: 
double _x,_y,_z; 
//la dim_ensione dell' array e' superflua tra i dati membro di point, di cui 
//occorrono tutte e solo le coordinate, e i metodi per gestirle

public: 
void point();
void point(double, double, double);
void -point() //distruttore: attenzione il - e' una tilde ma non la trovavo ora come ora 
//l' utilita' di una classe e' accorpare i metodi con i dati interni
double getx();
void setx(double x); 

double gety();
void sety(double x);

double getz ();  
void setz(double x); 
}

point::point(){ 
_x = 0; 
_y = 0; 
_z = 0; 
} ;

point::point(const double x, const double y, const double z) 
{ 
_x = x; 
_y = y; 
_z = z; 
} ;
//get e set implementate anche per y e z
double point::getx()
{
return _x:
};

void point::setx(double x)
{
_x=x;
};

[progC__]

.... Non questo quello che volevo sapere...la domanda riguardava i costruttori per quanto riguarda l'ereditarietà...

[jappilas]

Originariamente inviato da progC__

.... Non questo quello che volevo sapere...la domanda riguardava i costruttori per quanto riguarda l'ereditarietà...

tu tieni presente che ereditando una classe si ereditano tutti i dati e metodi membri di quella classe, quindi nel costruttore della derivata si chiamera' il costruttore della classe genitore per inizializzare i cambi ereditati, per poi occuparsi di quelli aggiunti

[progC__]

Originariamente inviato da jappilas

tu tieni presente che ereditando una classe si ereditano tutti i dati e metodi membri di quella classe, quindi nel costruttore della derivata si chiamera' il costruttore della classe genitore per inizializzare i cambi ereditati, per poi occuparsi di quelli aggunti

come faccio a chiamare il costruttore della classe base dato che il costruttore point inizializza elementi privati...non accessibili da vector...quale sintassi dovrei usare...tipo questa: vector() : point()....

[jappilas]

Originariamente inviato da progC__

come faccio a chiamare il costruttore della classe base dato che il costruttore point inizializza elementi privati...non accessibili da vector...quale sintassi dovrei usare...tipo questa: vector() : point()....

chiediti non solo "come faccio" a chiamare il costruttore (quello è il meno come vedrai), chiediti anche "perchè" ereditare una classe

class a
{
 private:
 int dato;
public:
void a(int a) : dato(a){}
}

class b:public a
{
private:
int dato2;
public: 
void b(int n1,n2) : a(n1), dato2(n2) {}
}

questo per la forma

quello che dicevo prima è che che in questo caso mi pareva perdessi di vista il senso dell' ereditarieta', che consiste nell' estendere una classe base : ereditare da una classe base implica che un oggetto di tipo derivato è anche del tipo base
tu vuoi creare un vettore come derivato da point...
ma un vettore sarà un contenitore per piu' elementi di tipo point (*), non un point a sua volta: per questo dicevo in questo caso non andrebbe applicata l' ereditarietà, ma la semplice scrittura di due classi diverse, di cui la seconda ha come dati membro oggetti il cui tipo è la prima classe
(*) a meno che non intendi il vettore nel senso della geometria analitica, definito da una n-pla di grandezze riferite a una base ortonormale di coordinate e corrispondente ognuna ad uno di n versori
nella fattispecie, un vettore non contiene più punti , ma ha la stessa struttura della classe punto, quindi anche in questo caso l' ereditarietà non c' entra

[progC__]

è giusto scrivere così....

//definizione classe derivata vettore di tipo public
class vector : public point{

private:
double x1,y1,z1;
public:

vector() : point(){
x1 = 0;
y1 = 0;
z1 = 0;
}

};

[fek]

Originariamente inviato da progC__

è giusto scrivere così....

//definizione classe derivata vettore di tipo public
class vector : public point{

private:
	double x1,y1,z1;
public:

vector() : point(){
		   x1 = 0;
		   y1 = 0;
		   z1 = 0;
	   }

};

Si', sintatticamente e' corretto.
Volendo fare i pignoli:

vector() 
  : point()
  , x1(0.0)
  , y1(0.0)
  , x1(0.0)
{
}

Sistemata la sintassi, passiamo all'aspetto del design.

Perche' vuoi ereditare vector da point?

Un vettore non e' un punto, il principio di sostituzione non si applica in questo caso, quindi usare l'ereditarieta' e' un errore di design. L'ereditarieta' non dev'essere (quasi) mai uno strumento per riutilizzare il codice, ma uno strumento per modellare le entita' che partecipano al design.

Quindi, un vettore e' composto da due punti.

Ecco come puoi modellare questa relazione in codice:

class Vector3D
{
public:

  Vector3D()
    : m_Point0()
    , m_Point1()
  {
  } 
  
private:
  Point3D m_Point0;
  Point3D m_Point1;  
};