Duda con los constructores

[OscarMariano]

Buenas a todos tengo una duda con los constructores pondre mi codigo para explicar el problema.

//cabezera
#pragma once
#include <iostream>
#include <string>
using namespace std;

class Persona{

private:
int edad;
string nombre;
public:

Persona();
Persona(int,string);

void setEdad(int);
int getEdad(void);

void setNombre(string);
string getNombre(void);

};
//fin cabezera

//implementacion cabezera

#include "Persona.h"
Persona::Persona(){
cout<<"Ingrese la edad";
cin>>edad;
cout<<"Ingrese su nombre";
cin>>nombre;
}

Persona::Persona(int e,string nom){
edad=e;
nombre=nom;
}

void Persona::setEdad(int e){
edad=e;
}
int Persona::getEdad(void){
return edad;
}

void Persona::setNombre(string nom){
nombre=nom;
}
string Persona::getNombre(void){
return nombre;
}
// fin implementacion

//main

#include "Persona.h"

int main(){

Persona p = new Persona(8,"asd");
//UNO DE LOS ERROES ES EN EL NEW ME DICE QUE
NO EXISTE NINGUN OPERADOR ADECUADO PARA CONVERTIR DE
" Persona *" a "Persona"


return 0;
}

Esa es mi duda agradezco sus respuestas porque mi mayor proplema
siempre fueron los constructores, y una duda mas el constructor por defecto
lo puse asi porque asi lo vi en otro ejemplo pero siempre pense que el constructor
por defecto iva vacio , gracias nuevamente espero sus respuestas.

[sam90]

Esa linea deberia ser:

Persona * p = new Persona(8,"asd");

Ya que new devuelve un puntero a la instancia.

Saludos

[Aemilius]

Otra forma, usando memoria de pila:

Persona p(8,"asd");

En este caso el destructor seá llamado al final del contexto de p, asi como la memoria utilizada por p será automaticamente liberada (Nada de magia aqui, si reservaste memoria en el heap por tu cuenta para algún miembro puntero de p, tambien tienes que liberarla por tu cuenta). Como es memoria reservada en pila esto es muchísimo más rápido que reservar/liberar memoria en el heap ya que no es necesario ninguna sincronización con otros hilos y prácticamente se traduce en simple suma/resta en lugar de tener que actualizar una lista de zonas de memoria reservadas o libres en el heap. Evidentemente esta forma es menos flexible que usar memoria del heap puesto que el inicio y fin de la vida del objeto están decididos a tiempo de compilación por el contexto de la variable.

Por ejemplo:

Código:

// Usando llaves para definir un inicio/fin de contexto.
{
    // En este punto no existe p

    // Inicio del contexto de p
    Persona p(8,"asd");
    // Logica que usa p

    // Fin del contexto de p, el destructor de p es llamado en este punto
}
// En este punto tampoco existe p

[OscarMariano]

Iniciado por Aemilius

Otra forma, usando memoria de pila:

Persona p(8,"asd");

En este caso el destructor seá llamado al final del contexto de p, asi como la memoria utilizada por p será automaticamente liberada (Nada de magia aqui, si reservaste memoria en el heap por tu cuenta para algún miembro puntero de p, tambien tienes que liberarla por tu cuenta). Como es memoria reservada en pila esto es muchísimo más rápido que reservar/liberar memoria en el heap ya que no es necesario ninguna sincronización con otros hilos y prácticamente se traduce en simple suma/resta en lugar de tener que actualizar una lista de zonas de memoria reservadas o libres en el heap. Evidentemente esta forma es menos flexible que usar memoria del heap puesto que el inicio y fin de la vida del objeto están decididos a tiempo de compilación por el contexto de la variable.

Por ejemplo:

Código:

// Usando llaves para definir un inicio/fin de contexto.
{
    // En este punto no existe p

    // Inicio del contexto de p
    Persona p(8,"asd");
    // Logica que usa p

    // Fin del contexto de p, el destructor de p es llamado en este punto
}
// En este punto tampoco existe p

y me podrias decir cual es la diferencia entre estos tipos de declaracion?

Persona *p = new Persona;
Persona *p = new Persona();

[Aemilius]

Si no definiste un "constructor por defecto"* entonces "new Persona();" inicializará los miembros a 0. En cambio "new Persona;" y "Persona p;" no inicializarán los miembros.
Esto se hace más complicado si alguno de los miembros es a su vez una clase o struct, en tal caso es mejor definir un constructor por defecto. En GCC la regla de inicializar a 0 se mantiene, pero en MSVC los miembros ya no se inicializan a 0 si alguno de los miembros (o uno de los miembros de los miembros) tiene un constructor por defecto.

Nota: "constructor por defecto" es un constructor que puede ser llamado sin especificar parámetros, esto incluye constructores que tienen parámetros con valores predefinidos.

Este comportamiento es especialmente útil si deseas inicializar los elementos de un arreglo a 0:

// Reservando memoria sin inicializar
char* pChar = new char[10];

// Reservando memoria y además inicializando a 0:
char* pChar = new char[10]();

Ejemplo:

Código:

#include "stdio.h"

class PersonaSinConstructor
{
public:
	int _edad;
};

class PersonaConConstructor
{
public:

	PersonaConConstructor() : _edad(100)
	{
	};

	int _edad;
};

int main(int argc, char** args)
{

	PersonaConConstructor* pA = new PersonaConConstructor;
	PersonaConConstructor* pB = new PersonaConConstructor();
	PersonaConConstructor C;

	PersonaSinConstructor* pD = new PersonaSinConstructor;
	PersonaSinConstructor* pE = new PersonaSinConstructor();
	PersonaSinConstructor F;

	printf("Edad A (Inicializado a 100): %i\n", pA->_edad);
	printf("Edad B (Inicializado a 100): %i\n", pB->_edad);
	printf("Edad C (Inicializado a 100): %i\n", C._edad);
	printf("Edad D (Sin inicializar): %i\n", pD->_edad);
	printf("Edad E (Inicializado a 0): %i\n", pE->_edad);
	printf("Edad F (Sin inicializar): %i\n", F._edad);

	delete pA;
	delete pB;
	delete pD;
	delete pE;

	return 0;
}

[OscarMariano]

Se agradece ahora todo esta mas claro :D