Mensajes

de verdad?, que extraño, entonces tengo que ver el resto del codigo

Hola!

Estoy intentando crear una agenda y me he topado con algo que me parecio extraño:

Código (cpp) [Seleccionar] Expandir


//Persona.h
class Persona{

       int edad;

public:
       Persona() : edad(60){};
       int LeerEdad() const {
              return this->edad;
       }

};


Código (cpp) [Seleccionar] Expandir


//main.cpp
#include <iostream>
#include "Persona.h"

Persona * personas;

int main (){
       
       personas = new Persona;

       std::cout << personas->LeerEdad() << std::endl   //Esto imprime 60

       std::cout << personas[0].LeerEdad() << std::endl //Esto imprime 223525

       return 0;

}


Me parecía haber leido en alguna parte que personas y personas[0] apuntaban al mismo segmento de memoria..... pero están imprimiendo dos valores diferentes... No son lo mismo?  El uso que quiero darle a "personas" es el de un arreglo.


Saludos y gracias.

Si, @Loretz , lo que esperaria ahí es Segment fault 11... tienes razon, aunque lo escribi a la rapida para mostrar mi problema de ostream mas que nada... 

@Yrex-DwX ya me di cuenta que con ostring no sacaba nada jajha

entnoces no era obligación meter la palabra "friend", sabía!.. no me hacía sentido, simplemente tenía que declarar y definir fuera de la clase esta sobrecarga ....

He usado también la sobrecarga == y ésta sí que se comporta como yo esperaba dentro de la clase, por lo visto no todos los operadores se sobrecargan de la misma forma verdad?.

Estuve observando el ostream que mencionas, pero por mas que veo, se me pasa el error, no lo veo, en qué linea está ?..

Saludos y gracias.

buen punto... lo tendré en cuenta la siguiente vez.. 

Buenas amigos..

Tenía entendido que la palabra reservada "friend" permitía acceder a todas mis variables privadas de mi clase desde fuera, es como una excepción a la regla, para friend sería todo publico.

He querido utilizar el operador sobrecargado << para que mi clase pueda ser impresa por la salida estándar.

Esto es lo que tengo:

Código (cpp) [Seleccionar] Expandir


//Persona.h
#include <iostream>

class Persona{

    char * nombre;
    int edad;

public:

    Persona();
    ~Persona();
   
    //La siguiente linea da error si no coloco la palabra friend al principio
    std::ostream & operator<<(std::ostream & os, Persona & _estaPersona);
    char * LeerNombre() const;
    int LeerEdad() const;
     void InsertarNombre(const char * _nuevoNombre);
     void InsertarEdad(const int _nuevaEdad);

};


Código (cpp) [Seleccionar] Expandir


//Persona.cpp

#include "Persona.h"

using namespace std;

//Sobrecarga operador
ostring & operator<<(ostring & os, const Persona & _estaPersona){
    os << "Nombre : " << _estaPersona.LeerNombre() << endl;
    os << "Edad     : " << _estaPersona.LeerEdad() << endl;
    return os;
}

char * Persona::LeerNombre(){
    return nombre;
}

int Persona::LeerEdad(){
    return edad;
}

void Persona::InsertarNombre(const char * _nuevoNombre){
    strcpy(nombre, _nuevoNombre);
}

void Persona::InsertarEdad(const int _nuevaEdad){
    edad = _nuevaEdad;
}



Código (cpp) [Seleccionar] Expandir


//main.cpp
#include Persona.h

int main (){
    Persona p;
    p.InsertarNombre("ElHacker");
    p.Edad(37);
   
    std::cout << p << endl;
}


Lo que no entiendo, es que según la definición de friend, esto no me calza, yo no quiero acceder desde fuera a una propiedad privada, solo estoy intentando acceder a LeerNombre() y LeerEdad() que son publicas, no debería necesitar colocar friend... es que acaso friend con el operador trabaja de forma distinta?

Gracias de antemano.

No te entendi, cual es el valor que se pierde que había asignado antes?..

EDIT:

Ah!, te refieres a que no debí haber escrito :

Código (cpp) [Seleccionar] Expandir

int * punteroSuma = new int;

sino:

Código (cpp) [Seleccionar] Expandir

int * punteroSuma = sumar(a, b);

directamente, verdad?...

Es como que cuando solicité memoria al declarar punteroSuma, esa memoria la dejé botada y pasé el puntero al valor de retorno de Suma.. creo que a eso te refieres...

Perfecto, y esos dos últimos que mencionaste (unique_ptr y shared_ptr) serian punteros inteligentes no ?..

entiendo, entiendo...

tengo que imaginar al delete como un interruptor que desactiva el espacio de memoria
y al new como que lo activa..  podría ser así la abstracción.

Gracias nuevamente!! :

Gracias por las respuestas a ambos.. me ha quedado mucho mas claro ahora con lo ultimo que han dicho..

Una ultima duda:

Código (cpp) [Seleccionar] Expandir



int * sumar(int a, int b){
    int * psuma = new int;
    *psuma = a + b;
    return psuma;

}

int main (){
    int a = 5;
    int b = 10;

    int * psuma = new int;    //duda con el nombre psuma
    psuma = sumar(a, b);
   
    delete psuma;                //aqui se elimina psuma, pero cual?, el declarado
                                        //en main solamente o los dos?

}



Que pasa en el siguiente caso ?

Código (cpp) [Seleccionar] Expandir



int * sumar(int a, int b){
    int * psuma = new int;
    *psuma = a + b;
    return psuma;

}

int main (){
    int a = 5;
    int b = 10;

    int * punteroSuma = new int;    //modificado el nombre
    punteroSuma = sumar(a, b);
   
    delete punteroSuma;      //aqui se elimina psuma, punteroSuma o ambos?
}




Gracias!