Ohhhh! Entiendo! Muy buena respuesta!
Gracias!!

Bah... a mi me compila muy bien y arroja el resultado esperado.
No sabría decirte el porqué en tu caso no compila.

Ahora bien, de regreso a mi consulta..., sabes quizás si es posible realizar lo que describo?

Saludos!

Hola!

Muchas gracias por tu respuesta!

Está muy bueno! 

Sin embargo, tengo el interés de saber si existe la posibilidad de hacer lo mismo sobrecargando operadores usando templates. Es un interés personal, pues, no he hallado una solución en la web ni en los libros de los que dispongo.

Quisiera saber si existe un método de esa manera, o si no es posible hacerlo de esa manera.
Mi segunda consulta va en relación al comentario

"Tienes hecha mal la sobrecarga."

Sobre qué base se levanta tu comentario?

Saludos!

Hola a todos!

Estoy tratando de aprender por mi misma los elementos básicos de C++.
He buscado en la web una respuesta a la siguiente duda, pero no la he hallado.

Quizás este problema no tiene solución.

Es posible traspasar un operador a un template de modo tal que el operador no solamente sea sobrecargado sino que a la vez sea reemplazado por otro, y de ese modo no sea necesario tener que repetir el mismo código solo por cambiar la operación, o sea, algo como esto:

Num operator +(const Num &p1,const Num &p2)
{
    Num erg;
	erg.a = p1.a + p2.a;
	erg.b = p1.b + p2.b;
    return erg;
}
 
Num operator *(const Num &p1,const Num &p2)
{
    Num erg;
	erg.a = p1.a * p2.a;
	erg.b = p1.b * p2.b;
    return erg;
}
 
Num operator -(const Num &p1,const Num &p2)
{
    Num erg;
	erg.a = p1.a - p2.a;
	erg.b = p1.b - p2.b;
    return erg;
}
 

etc....

A continuación les dejo el código. Es uno sencillo del que muchos similares pueden encontrarse en libros y en la web:

#include <iostream>
 
using namespace std;
 
class Num 
{	
	public:
    double a, b;
};
 
Num operator +(const Num &p1,const Num &p2)
{
    Num erg;
	erg.a = p1.a + p2.a;
	erg.b = p1.b + p2.b;
    return erg;
}
 
int main()
{
    Num num1;
	num1.a=1;
	num1.b=75;
    Num num2;
	num2.a=150;
	num2.b=175;
    Num num1und2 = num1 + num2;
 
    cout << "num1 " << "a: " << num1.a << ", b: " << num1.b << endl;
    cout << "num2 " << "a: " << num2.a << ", b: " << num2.b << endl;
    cout << "num1und2 " << "a: " << num1und2.a << ", b: " << num1und2.b << endl;
 
    return 0;
}
 

Ese código me gustaría poder reescribir más o menos como sigue, de modo que sea posible traspasar al templete el operador:

#include <iostream>
 
using namespace std;
 
class Num 
{	
public:
    double a, b;
};
 
template<operator op> 	// * Algo por este estilo
Num operator op(const Num &p1,const Num &p2)
{
    Num erg;
	erg.a = p1.a op p2.a; 	// * Donde dice op que sea reemplazado por el operador deseado
	erg.b = p1.b op p2.b;   // * Donde dice op que sea reemplazado por el operador deseado
    return erg;
}
 
int main()
{
    Num num1;
	num1.a=1;
	num1.b=75;
 
    Num num2;
	num2.a=150;
	num2.b=175;
 
    Num num1und2 = num1 + num2;		// * Modificando acá el operador que cambie arriba la operación
 
   	cout << "num1und2 " << "a: " << num1und2.a << ", b: " << num1und2.b << endl;
 
    return 0;
}
 

Es posible realizar una hazaña de ese tipo?

Hola!

Primero que todo agradecer tu respuesta.

Muchas gracias por el -s flag.

Efectivamente resultan ambos ejecutables generados del mismo tamaño.

Tomaré entonces la proposición que dice que un constructor implícito es generado por el compilador como correcta.

Saludos!

Hola a todos!

Tengo una duda de curiosidad.

Dispongo de dos libros diferentes sobre C++. Al revisar el tema constructores plantea uno de ellos que cada clase tiene al menos un constructor. De no definirse uno por quien escribe el código, coloca el compilador un constructor por defecto, o sea: Constructor(){}, automáticamente.

El otro libro, que hasta ahora me ha parecido bastante mejor que el recién señalado, dice que cada clase puede tener ninguno, uno o más constructores. NO dice que el compilador establece, en caso de ausencia plena de uno explícitamente definido, uno implícitamente. De lo contrario, el programa puede funcionar, pero pueden surgir problemas con la inicialización del objeto y en general con el funcionamiento del programa, dado que el sistema de ejecución asume un constructor por defecto.

Así que me he puesto a googlear... Y he visto que en varias partes se sostiene lo mismo que en el primer libro referido.

Ahora bien, no soy novata, pero estoy lejos de ser diestra en C++ OOP.

Sin embargo, hice un experimento, para determinar cuál de ambos puntos de vista, es el correcto.

Escribí un pequeño código de prueba una vez sin y una vez con la declaración explícita de un constructor por defecto.

A continuación el programa con un objeto poco afín al trabajo pero hablador sin haber declarado un constructor:

#include <iostream>
 
using namespace std;
 
class Constuctor
{
    private:
	void funktion_work()
	{ cout << "I have to work... Buhhhh" << endl;  }
 
   	protected: 
	void funktion_lenguagesConstuctor()
	{ 	cout << "I can english." << endl;
		cout << "I can deutsch." << endl;
		cout << "I can espaniol." << endl;
	}
 
   	public:
 
	void funktion_lenguagesConstuctor_public()
	{
		funktion_lenguagesConstuctor();
	}
};
 
int main(int argc, char **argv){
 
	Constuctor constructor; 
	constructor.funktion_lenguagesConstuctor_public();
 
return 0;
}
 

Y a continuación, lo mismo pero con un constructor explícitamente declarado (línea 21):

 
#include <iostream>
 
using namespace std;
 
class Constuctor
{
    private:
	void funktion_work()
	{ cout << "I have to work... Buhhhh" << endl;  }
 
   	protected: 
	void funktion_lenguagesConstuctor()
	{ 	cout << "I can english." << endl;
		cout << "I can deutsch." << endl;
		cout << "I can espaniol." << endl;
	}
 
   	public:
 
	Constuctor(){}
	void funktion_lenguagesConstuctor_public()
	{
		funktion_lenguagesConstuctor();
	}
};
 
int main(int argc, char **argv){
 
	Constuctor constructor; 
	constructor.funktion_lenguagesConstuctor_public();
 
return 0;
}
 
 

Lo que me parece interesante es que el programa resultante es más pesado cuando tiene un constructor explícitamente declarado:

Peso del ejecutable sin constructor declarado: 21472 Bytes
Peso del ejecutable con constructor declarado: 21856 Bytes

La diferencia es de 384 Bytes.

De acuerdo a los pesos del ejecutable  tendría razón el libro que no señala la existencia de un constructor implícito colocado por el compilador y que hasta ahora me ha parecido un libro excelente.

Sin embargo, como ya decía, el otro libro y una gran parte de los textos en google dicen lo contrario.

Estoy confusa...  
Alguien tiene alguna mayor claridad sobre este tema?

Muy agradecida por vuestros comentarios me despido,
Gisi

Hola! Mira, resulta que he hallado, tras mucho experimentar, la solución buscada. La esencia del problema, al menos de acuerdo a mi solución, era colocar al vector dentro de una función. De ese modo es posible trabajar con él y al mismo tiempo, heredar de la clase padre.

Acá dejo el código. De todos modos, no lo hubiera logrado sin tus correcciones!  
Muchas gracias!

#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
//Klasse einrichten
class Patient
{
private:
	string fname;
	string sname;
 
	void privateFunción()
	{	
		//string _sname, _fname; 	// Falls man durch Tastatureingabe Vektor füllen
											// will.
		vector<Patient>vielePatient;
		vectorfuellen(vielePatient);
		printVector(vielePatient);
	}
 
public:
	~Patient(){}
 
	Patient(){ }
 
	// Zum aufrufen der privaten Función
	void publicFunción()
	{ privateFunción(); };
 
	void setFistname(string _fname)
	{ fname = _fname; }
 
	void setSecondname(string _sname)
	{ sname = _sname; }
 
	void setName(string _fname, string _sname)
	{ fname = _fname;
	sname = _sname;}
 
	string getSecondname() const { return sname; }
	string getFistname() const { return fname; }
 
 
 
// Función para manipular al vector
// Función 1: llenar el vector
	void vectorfuellen(vector<Patient>& f_vielePatient)
	{
			Patient patient01;
			Patient patient02;
			Patient patient03;
 
			patient01.setName("me", "mo");
			patient02.setName("ma", "mu");
			patient03.setName("hu", "ju");
 
			f_vielePatient.push_back(patient01);
			f_vielePatient.push_back(patient02);
			f_vielePatient.push_back(patient03);
 
			// Falls man durch Tastatureingabe den Vektor füllen will. 
			// (Muss vieleicht etwas umgestellt werden.)
			/*cout<<"Apellido: ";
			cin >> _fname;
			//patient01.setFistname(_fname);
 
			cout<<"Nombre: ";
			cin >> _sname;*/
			//patient01.setSecondname(_sname);
 
			//patient01.setName(_fname, _sname);
	}
 
// Función 2: mostrar el vector
	void printVector(const vector<Patient>& p_vielePatient){
			for(int i=0; i<=p_vielePatient.size(); i++)
				{ cout << p_vielePatient[i].getFistname() << " " << p_vielePatient[i].getSecondname() << endl; }
	}
 
 
};
 
int main()
{
 
	Patient patient01;
	patient01.publicFunción();
 
return 0;
}  
 

Efectivamente he colocado el código con problemas. Y el error correspondiente que arroja también.
Ambos en el mensaje previo al anterior.
Por lo demás, di respuesta a tu comentario que dice que el vector se encuentra comentado y que sobre esa base es que el compilador no puede hallar al objeto database. Mi correspondiente respuesta fue que he ubicado el vector bajo public (comparar las líneas 41 y 38).

(No, si el error salta con esa parte no comentada. Eliminé el comentario. Lo había colocado, para probar lo que ocurre si dejo el vector en public.)

Ahora bien, efectivamente pretendo no agregar un vector al vector sino un único objeto, a saber el objeto database creado en main.

Porqué cuando tuve el vector en main (algo más arriba está el ejercicio) pude insertar el objeto con push_back y ahora que el vector se encuentra en una clase ya no?


Voy a probar la opción insert.

Hola!
Ya de a poco voy entendiendo mejor los conceptos. Como indicas hice el cambio de los nombres de los parametros.
Ahora bien, database es mi objeto que pretendo almacenar en el vector. maniPatien es el nombe del vector. Por lo que tengo entendido es que la sintaxis de un un push_back es:

NombreVector.push_back(ObjetoAAgregarEnVector);

Yo quiero trapasar mi objeto creado en main database al vector.

void patInsert(vector<Patient>& database)
    {
         //NombreVector.push_back(ObjetoAAgregarEnVector);
         manyPatient.push_back(database);
         cout << endl;
    }
 

El objeto database lo tengo creado con la siguiente declaración:

        // Las variables
	string _sname, _fname;
        // Creación objeto database de la clase PatientDatabase
        PatientDatabase database;
 
        // Se llenan las variables
	cout<<"Apellido: ";
	cin >> _fname;
 
	cout<<"Nombre: ";
	cin >> _sname;
 
       // Se  traspasa la información de las variables por setter.
	database.setName(_fname, _sname);
 
 

Quizás, lo que me intentas señalar es que el vector no debería estar colocado en una clase que hereda sino en la misma clase a la que pertenece. Y que por eso el compilador no reconoce al objeto database creado en main.

Es ese error lógico mío que intentas hacerme entender?

Saludos y muchas gracias.

Dejo acá el código completo:

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <stdio.h>
#include <vector>
 
using namespace std;
 
class Patient
{
protected:
    string fname;
    string sname;
 
public:
	~Patient(){}
 
	Patient(){ }
 
	void setName(string _fname, string _sname)
	{ fname = _fname; 
	  sname = _sname;}
 
	/*void setFirstname(string _fname)
	{ fname = _fname; }
 
	void setSecondname(string _sname)
	{ sname = _sname; }*/
 
	string getSecondname() const { return sname; }
	string getFirstname() const { return fname; }
};
 
class PatientDatabase : public Patient
{
   private:
		//vector tipo clase Patient.
   	//vector<Patient> manyPatient;
   public:
   PatientDatabase(){}
   	vector<Patient> manyPatient;
	   	//Copia del vector clase Patient
   /*vector<Patient> GetCopyOfVector()
   { return manyPatient; }*/
 
		// Escribir en la copia del vector
	void patInsert(vector<Patient>& manyPatientFull)
    {
         manyPatientFull.push_back(database);
         cout << endl;
    }
 
		// Imprimir el vector en pantalla
    void printVectorPatientDatabase(const vector<Patient>& manyPatientShow)
    {
        int i;
        int size = manyPatientShow.size();
 
        for(i=0; i<size; i++)
        {
				cout << manyPatientShow[i].getFirstname() << " " << manyPatientShow[i].getSecondname() << endl;
        }
    }
};
 
int main()
{
	string _sname, _fname;
 
        PatientDatabase database;
 
	cout<<"Apellido: ";
	cin >> _fname;
 
 
	cout<<"Nombre: ";
	cin >> _sname;
 
 
	database.setName(_fname, _sname);
 
    return 0;      
}     
 
 

Y acá el error:

In member function ‘void PatientDatabase::patInsert(std::vector<Patient>&)’:
prog.cpp:48:10: error: ‘manyPatient’ was not declared in this scope
          manyPatient.push_back(database);