Klasa i konstruktory c++

Mam stworzyć klasę osoba która będzie posiadała konstruktor:
-pusty wprowadzający wartości pól do dynamicznie alokowanych zasobów.
-przyjmujący 2 parametry (char* , int)- inicjujący pola przez listę inicjacyjną.
Oba konstruktory mają wyświetlać informacje o utworzeniu obiektu osoba. Muszę również dodefiniować destruktor tak aby wyświetlał informację o zniszczeniu obiektu i zwalniający dynamicznie zaalokowane zasoby.
Napisałem coś takiego:

#include <iostream>
#include <cstring>
using namespace std;
class Osoba{
char* imie;
int wiek;
public:
Osoba(){
char* im;
int wi;
cin>>im;
cin>>wi;
strcpy(imie,im);
wiek=wi;
cout<<"Obiekt zostal utworzony"<<endl;
}
Osoba(char* a,int b)
:
imie(a),
wiek(b)
{cout<<"Obiekt zostal utworzony"<<endl;
}
~Osoba(){
	cout<<"Obiekt zostal zniszczony"<<endl;
}
};

int main ( ) {
Osoba* o1=new Osoba();
Osoba o2=Osoba("Andrzej",22);
return 0 ;
} 

Prosiłbym kogoś o sprawdzenie tego kodu czy jest to rozwiązanie zadania i ewentualne podpowiedzi co jest źle. Szczególnie nie jestem pewny tego konstruktora z dynamicznie alokowanymi zasobami. Będę wdzięczny za wszelkie podpowiedzi.
Pozdrawiam

Tutaj nigdzie nie ma żadnego dynamicznego alokowania. Konstruktor domyślny to jeden wielki błąd. Konstruktor z dwoma argumentami też jest niedobry: łańcuch powinien być kopiowany, czego nie da się zrobić w liście inicjalizacyjnej da się to jednak zrobić w liście inicjalizacyjnej jak pokazał @_13th_Dragon. Zasadniczo musisz poczytać o dynamicznym przydziale pamięci za pomocą new. (Albo zacząć używać std::string)

Jeżeli klasa zawiera wskaźniki to w 99% przypadków należy też zaimplementować konstruktor kopiujący i operator przypisania. Dodatkowo destruktor powinien zwalniać zajęte zasoby. Twój akurat nie ma czego zwalniać, bo jak napisałem wyżej niczego nie alokujesz.

Bonus: zacznij jakoś normalnie formatować kod bo od tego bolą oczy.

Endrju napisał(a):

... łańcuch powinien być kopiowany, czego nie da się zrobić w liście inicjalizacyjnej
Czyżby?

class Osoba
  {
   char *imie;
   unsigned wiek;
   static char *cp(const char *str) { unsigned sz=strlen(str)+1; char *ret=new char[sz]; memcpy(ret,str,sz); return ret; }
   Osoba(const char *imie,unsigned wiek):imie(cp(imie)),wiek(wiek) {}
   ...
  };

Nie wiem dlaczego ale po uzyciu konstruktora ktory napisal 13th dragon program mi sie zawiesz i wyskakuje blad ...

Czy teraz konstrukor pierwszy jest poprawny?

 
....
Osoba(){
char* im;
int wi;
cin>>im;
cin>>wi;
int *wie=new int(wi);
wiek=*wie;
imie = new char[strlen(im)+1];
strcpy(imie,im);
cout<<"Obiekt zostal utworzony"<<endl;
}
....

Czy dalej nie o to chodzi ?

char* im; // wskazuje na "losowy" obszar pamieci
int wi;
cin>>im; // wczytujesz coś do tego losowego obszaru pamięci.

mógłbym poprosić Cie o to żebyś w takim razie pokazał jak to powinno być zrobione poprawnie ponieważ nie mogę jakoś na to wpaść

np tak:
Osoba() { char bufor[100+1]; cin>>setw(100)>>bufor>>wiek; imie=cp(bufor); }

Dodałem konstruktor kopiujący tak jak mi poradziliście . Teraz wygląda to tak jednak nadal mam problem z tym konstruktorem z dynamicznym alokowaniem zasobów ....

 
#include <iostream>
#include <cstring>
using namespace std;
class Osoba{
public:
char* imie;
int wiek;
Osoba(){
char* im;
int wi;
cin>>im;
cin>>wi;
int *wie=new int(wi);
wiek=*wie;
delete wie;
imie = new char[strlen(im)+1];
strcpy(imie,im);
cout<<"Obiekt zostal utworzony"<<endl;
}
 static char *cp(const char *str) { int sz=strlen(str)+1; char *ret=new char[sz]; memcpy(ret,str,sz); return ret; }
Osoba(const char *imie,int wiek):imie(cp(imie)),wiek(wiek) 
{cout<<"Obiekt zostal utworzony"<<endl;}
Osoba(const Osoba& os) { 
wiek = os.wiek;
imie = new char[strlen(os.imie)+1];
strcpy(imie,os.imie);
         }
void show(){
cout<<imie<<endl;
cout<<wiek<<endl;
}
~Osoba(){
	delete[] imie;
	cout<<"Obiekt zostal zniszczony"<<endl;
}
};

int main ( ) {
Osoba* o1=new Osoba();
Osoba &o2=*o1;
o2.show();
Osoba o=Osoba(o2);
o2.show();
o.show();
delete o1;
o.show();
o2.show();
return 0 ;
}

Osoba(const Osoba &os):imie(cp(os.imie)),wiek(os.wiek) {}
brakuje ci też operatora przypisania.