Entiendo, ya me va quedando todo mas claro... gracias por las respuestas..

Vaya Stroustup, que le gusta complicar las cosas, pero supongo que es para mejor...

Hola, tendre en cuenta esa convención de las variables, gracias.
puede ser de la siguiente forma?:

int un_numero = 6;
 

o es mejor asi? :

int unNumero = 6;
 

Respecto a la autoasignacion del operador =, C++ lo hara para todos los tipos creados por el usuario que no haya recargado el operador = ? o tiene distinciones ?..

Saludos y gracias.

Buenas..

Me ha causado extrañeza la forma en que se puede inicializar un tipo a traves de un argumento al constructor:

struct s {
private:
	int x = 0;
public:
	s(int _x) : x{ _x } {}
	void p() const { std::cout << x; }
	int getx() const { return x; }
};
 
int main() {
	s _s(5);                                       //forma argumento a constructor 1
	s _t = 6;                                     //forma argumento a constructor 2
	s _u{ 7 };                                   //forma argumento a constructor 3
	s _v = { 8 };                              //forma argumento a constructor 4
 
	std::cout << std::endl;
	std::cout << _s.getx() << std::endl;		//salida : 5
	std::cout << _t.getx() << std::endl;		//salida : 6
	std::cout << _u.getx() << std::endl;		//salida : 7
	std::cout << _v.getx() << std::endl;		//salida : 8
	return 0;
}
 

Siempre he inicializado un tipo (que reciba un argumento de constructor) con los parentesis, es decir, tal como sale en la salida 5, es decir:

s _s(5);
 

Sin embargo, estaba convencido que la siguiente linea solo tenia como fin la asignacion de un valor:

s _t = 6;
 

Me ha parecido curioso porque se supone que una asignacion por regla general debe tener el mismo tipo que el asignado... sin embargo, el tipo s no es un entero.


Entonces me pregunto si esa linea realmente es una asignacion o lleva otro nombre....

@#Loretz.. efectivamente, olvide darle un valor por default en el constructor.
Respecto al puntero this, pues si, es que el código es borrador, lo hago nada mas que para fines de practica... en un reléase, el this lo utilizo siempre y cuanod tenga dos o mas variables que tengan el mismo nombre..

Aproposito, muchas gracias por compartir lo de la regla de 3...
creo que defintivamente tengo que echarle una repasadita al constructor de copia ademas..


#@String Manolo, pues si, solo que como el puntero d es privado, estoy accediendo con el getter..

Tienes razón!... me había preocupado de sobrecargar el operador + y no pensé en las consecuencias, debí haber cargado ademas el operador = y después << para imprimirlo...

La lección que me dio esto es que debo pensar en cada sobrecarga de operador necesaria pues una lleva a la otra...

Gracias

Hola nuevamente:

El siguiente código:

#include <iostream>
 
using namespace std;
 
struct s{
 
private:
    double * d = nullptr;       
 
public:
    s() : d{new double}{}
    ~s(){ if (d != nullptr) delete d; }
    void setd(const double _d){ *this->d = _d; }
    double getd() const { return *this->d; }
 
};
 
s operator+(const s & _s0, const s & _s1){
    s ns;
    ns.setd(_s0.getd() + _s1.getd());
    return ns;
}
 
int main(){
 
    s s0;
    s s1;
 
    s s2;
    s2 = s0 + s1;
 
    return 0;
}
 
 

Aqui listo para ejecutar:
https://onlinegdb.com/rJNPQ68kr

Al ejecutar, obtengo el mensaje de error:

*** Error in `./a.out': double free or corruption (fasttop): 0x0000000000795c80 ***                                             
Aborted (core dumped)

Estoy seguro que el problema esta entre el puntero privado y el delete en el destructor, ya que si no uso puntero, compila bien.

Sin embargo, he puesto puntero porque quiero entender qué está pasando.  Me da la impresión de que en la definición del operador+ como se crea el objeto ns al terminar el ámbito, se está destruyendo y esta eliminando el puntero.  Lo cual parece valido, pero no tendría por qué corromper la ejecución, se supone que estoy destruyendo un objeto de copia, no los operandos utilizados.

Si, gracias, Lo veo.

Vaya si, me he equivocado al replantear el ejemplo, debi reemplazar x por typeX al final en el cout...


Bueno, comentar que he pasado el argumento por referencia y ahí no me ejecutó el constructor....  lo cual ahora que lo veo bien si es lógico..

de repente es algo confuso saber cuando retornar una referencia o una copia y cuando aceptar un argumento como referencia o como copia en los operadores sobrecargados...

gracias por la ayuda..

Hola..

haciendo algunos ensayos, me he encontrado con una sorpresa, cuando intento utilizar algún operador sobrecargado con un tipo propio, se ejecuta el constructor y el destructor al instante.... ej:

 
struct x{
 
private:
     int a;
 
public:
     x(){ std::cout << "Constructor ejecutado."; }
     ~x() { std::cout << "Deconstructor ejecutado."; }
     inline void setA(const int _a){ this->a = _a; }
     inline int getA() const { return this->a; }
}
 
std::ostream operator <<(std::ostream & _os, const x _x){
     _os << _x.getA();
     return _os;
}
 
 
 
int main(){
 
     x typeX;    //Constructor llamado como es usual..
     std::cout << x;     //Constructor y deconstructor llamados, por que?
 
}
 
 
 

entiendo, entonces es del IDE, no del compilador...
podria salvar varios minutos de compilacion...

llego un momento en que me pregunte : para que rayos tengo que darle un segundo argumento con el error si ya de antemano me lo esta señalando...

gracias por las respuestas.