Witam musze zrobić program ale mam problem,nie siedze w tym temacie i utknąłem.Brakuje mi 3 przykładów:
-skasowanie inteligentnego wskaźnika przez delete
-skopiowanie wskaźnika a potem skasowanie jednego,a następnie w odstępie ok 30s pierwszego(tak samo z inteligentnym)
pilna sprawa,
0
0
Jest to bezsensu, ale proszę bardzo, doslownie o co pytasz, na tyle doslownie na ile się dało:
a)
auto_ptr<cokolwiek*> * ptr = new auto_ptr<cokolwiek*>(0) // tworzy inteligentny wskaznik na stercie
delete ptr; // skasowanie go przez delete
b)
cokolwiek* ptr = ... np. new cokolwiek();
cokolwiek* inny = ptr; // kopia wskaznika
ptr = 0; // skasowanie wskaznika, chyba ze masz na mysli delete?
sleep(30*1000);
inny = 0; // skasowanie wskaznika, chyba ze masz na mysli delete?
auto_ptr<cokolwiek> ptr = .... np. auto_ptr<cokolwiek>(0)
auto_ptr<cokolwiek> inny = ptr; // kopiowanie intelig wskaznika
ptr.reset(); // skasowanie intelig. wskaznika
sleep(30*1000);
inny.reset(); // skasowanie intelig. wskaznika
Sadze jednak, ze chciales spytac o cos innego?
0
własnie mniej więcej o to mi chodziło.Musze pokazac jak sie zachowują zwykłe wskaźniki i inteligentne(z biblioteki boost) w tych przypadkach.Ale przy kasawaniu inteligetnego wskaźnika przez delete program mi sie zawiesza.A zaraz spróbuje tak jak napisałeś.A jeśli chodzi o skasowanie to chodziło mi o delete.Wkleje kod to bedzie jaśniej:
#include <iostream>
#include "smart_ptr.h"
using namespace std;
// alokuje 100mb pamieci
class pamiec
{
private:
// blok 1kb
struct blok
{
char *dane;
blok()
{
dane = new char[1024];
}
~blok()
{
if (dane)
delete [] dane;
}
};
int ilosc;
blok *lista;
public:
pamiec()
{
ilosc = 100*1024;
lista = new blok[ilosc];
cout << "-> zaalokowano pamiec\n";
}
~pamiec()
{
if (lista)
delete [] lista;
cout << "-> zwolniono pamiec\n";
}
};
///////////////////////////////////////////////////////////////
// zwykly wskaznik
// bez delete
void test1_1()
{
// alokuje pamiec
pamiec *p = new pamiec();
}
// poprawnie - z delete
void test1_2()
{
// alokuje pamiec
pamiec *p = new pamiec();
system("pause");
// zwalniam ja
if (p)
delete p;
}
// kopiowanie
void test1_3()
{
// alokuje pamiec
pamiec *p1 = new pamiec();
// kopiuje wskaznik
pamiec *p2 = p1;
system("pause");
// zwalniam pamiec
if (p2)
delete p2;
sleep(30*1000);
if (p1)
delete p1;
}
// przypisanie null
void test1_4()
{
// alokuje pamiec
pamiec *p = new pamiec();
system("pause");
// przypisuje 0, ale bez zwalniania!
p = NULL;
}
///////////////////////////////////////////////////////////////
// inteligentny wskaznik
// bez delete [ale poprawnie]
void test2_1()
{
// alokuje pamiec
scoped_ptr<pamiec> p; p.reset(new pamiec());
}
// z delete
void test2_2()
{
// alokuje pamiec
scoped_ptr<pamiec> p; p.reset(new pamiec());
// usuwam pamiec, ktora przechowuje ten wskaznik
if (p.get())
delete p.get();
// wysypuje sie, bo wskaznik nie ma na czym pracowac
}
// kopiowanie 1
void test2_3a()
{
// alokuje pamiec, jako zwykly wskaznik
pamiec *p1 = new pamiec();
// 'podpinam' ten wskaznik do inteligentnego wskaznika
scoped_ptr<pamiec> p2; p2.reset(p1);
system("pause");
// usuwam zwykly wskaznik z pamiecia
if (p1)
delete p1;
// czekam na zachowanie inteligentnego wskaznika, juz po jego wyczyszczeniu
}
// kopiowanie 2
void test2_3b()
{
// alokuje pamiec
scoped_ptr<pamiec> p1; p1.reset(new pamiec());
// przypisuje do zwyklego wskaznika inny wskaznik, przechowywany przez ten inteligentny
pamiec *p2 = p1.get();
system("pause");
// usuwam normalna metoda zawartosc inteligentnego wskaznika
if (p2)
delete p2;
// pamiec zwolniona - czekamy, co zrobi inteligentny wskaznik
}
// przypisanie null
void test2_4()
{
// alokuje pamiec
scoped_ptr<pamiec> p; p.reset(new pamiec());
system("pause");
// przypisuje null
p.reset(NULL);
}
int main()
{
cout << "Zwykly wskaznik" << endl;
cout << "1 zakonczenie programu bez delete" << endl;
cout << "2 poprawne zakonczenie z delete" << endl;
cout << "3 skopiowanie wskaznika" << endl;
cout << "4 przypisanie NULL" << endl;
cout << endl;
cout << "Inteligentny wskaznik" << endl;
cout << "5 zakonczenie programu bez delete" << endl;
cout << "6 poprawne zakonczenie z delete" << endl;
cout << "7 skopiowanie wskaznika (1 sposob)" << endl;
cout << "8 skopiowanie wskaznika (2 sposob)" << endl;
cout << "9 przypisanie NULL" << endl;
int numer;
cin >> numer;
if (numer == 1) test1_1();
if (numer == 2) test1_2();
if (numer == 3) test1_3();
if (numer == 4) test1_4();
if (numer == 5) test2_1();
if (numer == 6) test2_2();
if (numer == 7) test2_3a();
if (numer == 8) test2_3b();
if (numer == 9) test2_4();
cout << "Program zakonczyl prace\n";
system("pause");
return 0;
}
0
komenda sleep nie działa,pewnie nie w tym miejscu go wkleiłem:/czy trzeba jakąś biblioteke jeszcze doczucić do pliku nagłówkowego??działam na visual c++ nie wiem czy to ma znaczenie
0
jesli sprobujesz zdealokowac niewyzerowany wskaznik zwykly po tym, jak on juz owczesniej zostal zdealokowany -- albo jakas jego żywa kopia została zdealokowana, program zawsze Ci sie wychrzani.. nie ma bata ani innej mozliwosci. kropka. tak tego nie pokazesz, to bedzie ostatnia operacja Twojego programu przed śmiercią
jeśli dobrze zrozumialem co masz pokazac, adekwatna jest dla Ciebie opcja A), oczywiscie nie z (0zerem) tylko jakas zawartoscia, i nie auto-ptr ktory inteligentny jest jak gwóźdź, tylko boost::shared_ptr
// edit: tego posta pisalem zanim wkleiles kod.
// Sleep, nie sleep, pisze sie z duzej
// edit2, po obejrzeniu kodu: test1_3, test2_2, test2_3a, test2_3b - musza sie wysypac. taki jest Twoj zamiar? jesli oczekujesz inteligencji wskaznika w takich miejscach, sorry, nie licz na nia!
0
w pliku nagłówkowym smart_ptr mam implementacje scoped_ptr i z tego korzystam.poprawiłem na duża litere i to samo.Ma sie program nie wysypać.W żadnym przypadku.Muszę pokazać na programie graficznym jak pobiera ram i jak sie zwalnia pamięć.Wysypuje sie w test2_2 ,test2_3 a i b. A przypadku testu 1_3 i 2_3 powinno to tak wyglądac że po skasowaniu skopiowanego wskażnika pamięć po mału mi sie zwalnia i widać to na wykresie w programie graficznym,a po skasowaniu drugiego powinien byc spadek czyli cała pamięć zwolniona.To jak to ugryść ??
0
po pierwsze, odnosnie Twoich 'musiejstw':
1_3 : po skopiowaniu normalnego WSKAZNIKA:
- masz prawo tylko raz wykonac dealokacje, tylko na jednej z kopii. kropka.
- pamiec zostanie zwolniona natychmiast, w calosci, w momencie tegoż delete. kropka.
inaczej nie bedzie. jesli sprobujesz dwa razy dealokowac, wszechswiat wybuchnie. a jezeli w momencie delete pamiec sie nie zwolni, mozesz swoj komputer wywalic za okno, albo odinstalowac swoj 'program graficzny', gdyż kłamie albo pokazuje Ci cos, czego nie rozumiesz i jest czyms innym niz myslisz
2_3 : w momencie kiedy wykonasz delete na tym co zaalokowales przez new, pamiec zostanie zwolniona w calosci natychmiast. kropka. nie da sie tego opoznic ani spowolnic.
JEŻELI zas caly czas masz na mysli kopiowanie ZAWARTOSCI SPOD wskaznika i pokazanie ze "po skopiowaniu (""wskaznika i"") jego zawartosci na nowe miejsce" nagle pamieci zeżarto wiecej, zacznijże się wysławiać jak należy.
po drugie:
program graficzny to np. paintbrush albo photoshop, masz zapewne na myśli program posiadajace ladne kolorowe GUI, nie czarny, brzydki i bezwodotryskowy, pracujacy w konsoli? jakis 'okienkowy' taskmanager z wykresami wydajnosci/objecia pamieci itp?
po trzecie:
scoped_ptr nie jest tym, co Ty wydajesz sie uwazac za inteligentny wskaznik. Z tego co opisujesz wynika (przynajmniej dla mnie) ze chcesz aby Twoj inte-wskaznik sledzil co jest kopiowane i zwalnial pamiec dopiero gdy ostatnia zostanie puszczona. TAK SIE ZACHOWUJE BOOST::SHARED_PTR i mnie mało obchodzi że masz w reku lub na mysli cos innego, a tym mniej to obchodzi scoped_ptr'a ktorego uzywasz. boost::scoped_ptr jest tylko opakowaniem lokalnym na wskaznik, syjamsko-bliźniaczo podobnym do std::auto_ptr. tak samo jak ono, natychmiast zwalnia zawartosc jak tylko ow scopedptr wyjscie poza swoj scope klamer {}, kompletnie bez jakiegokolwiek sprawdzania czegokolwiek. ot tak, po prostu, natychmiast robi on delete na zapamietanym ptr* gdy tylko odpalisz(się) jego ~scopedptr albo reset(). od auto_ptr odroznia go tylko brak cctora z move semantics co intencjonalnie sprawia ze staje sie niezwracalny z funkcji/metod przez wartosc
przeczytaj opis klasy oraz metod: http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/scoped_ptr.htm i zrewiduj swoje poglady na zadanie
po czwarte:
szarpnij sie i zamiesc cala, co do slowa, niezmieniona tresc zadania ktore dostales do wykonania, gdyz jak na razie "sens" raptem majczy na horyzoncie pod postacia jedynego zdania
Muszę pokazać na programie graficznym jak pobiera ram i jak sie zwalnia pamięć
edit: a po sleepa, wez zajrzyj na google. czy uzywasz linuxa, czy windozy, sleep albo Sleep istnieje. wystarczy ze znajdziesz - uwaga - wlasciwy naglowek. podpowiem Ci ze na linuxie: man 3 sleep, zas na windozie: google +MSDN +Sleep
Nie mow mi tylko prosze, ze nie wiesz czym sa google, man, msdn lub ze nie udalo Ci sie..
Ah. i jezeli na linuxie, to uwazaj bo sleep i Sleep maja INNE skale parametrow
0
ok.No wiec tak. Musze pokazać jaz zachowują sie wskaźniki i inteligentne wskaźniki w takich przypadkach jak:alokacja pamięci
a)zakończenie programu bez delete
b)użycie delete
c)przypisanie do wskaźnika null
d)przypisanie wskaźnika do innego wskaźnika,skasowanie pierwszego (tu spadek pamieci),potem skasowanie drugiego(spadek pamięci)
Mam przedstawić za pomoca graficznego wykresu jak ta pamięc jest alokowana i dealokowana, tu już mam program Process Explorer.
W przypadku przypisania wskaźnika do innego wskaźnika przykład "d"to miałobyć tak że po skasowaniu jednego wskaźnika pamięć po mału zwalnia się,a po skasowaniu drugiego powinna cała sie zwolnić.W tym przypadku chciałem aby to było widoczne,aby mi pamięć tak szybko sie nie zwolniła,żeby było widać na wykresie jak powoli zwalnia sie a potam spada do "zera",żeby to nie było w jednym momencie.
A kasowanie inteligentnego wskaźnika przez delete,nie wiem jak to zrobić bo same inteligentne wskaźniki po to są aby nie korzystać z tej komendy.Profesor mi mówił że się da :/i jestem w kropce.Troche googlowałem ale nic nie znalazłem :/