Klasy c++, zmienne składowe, referencje

#include 

#include 


using namespace std;


class plan

{

public:

    plan(int &zapas_dostepny_koniec_tyg,int &prognozowany_popyt,int &zamowienia_zarezerwowane,int &nadrzedny_plan_produkcji)

    {

        c_zapas_dostepny_koniec_tyg=zapas_dostepny_koniec_tyg;

        c_prognozowany_popyt=prognozowany_popyt;

        c_zamowienia_zarezerwowane=zamowienia_zarezerwowane;

        c_nadrzedny_plan_produkcji=nadrzedny_plan_produkcji;

        c_planowany_SK_zapasow=0;

        oblicz_SK_zapasow();

    }

    ~plan()

    {

        //

    }


    const void zwroc_dane()

    {

        cout<
        cout<<"Zapas dostępny na koniec tygodnia = "<
        cout<<"Prognozowany popyt = "<
        cout<<"Zamówienie zarezerwowane = "<
        cout<<"Nadrzędny plan produkcji = "<
        cout<<"Planowany stan końcowy zapasów w danym tygodniu = "<
    }


    void oblicz_SK_zapasow()

    {

        c_planowany_SK_zapasow=c_zapas_dostepny_koniec_tyg+c_nadrzedny_plan_produkcji-zwroc_wieksza(c_prognozowany_popyt,c_zamowienia_zarezerwowane);

    }


    const int zwroc_wieksza(int &c_prognozowany_popyt,int &c_zamowienia_zarezerwowane)

    {

        if (c_prognozowany_popyt>c_zamowienia_zarezerwowane)

        {

            return c_prognozowany_popyt;

        }

        else

        {

            return c_zamowienia_zarezerwowane;

        }

    }


private:

    //zmienne do podania

    int c_zapas_dostepny_koniec_tyg;

    int c_prognozowany_popyt;

    int c_zamowienia_zarezerwowane;

    int c_nadrzedny_plan_produkcji;

    //zmienne do obliczenia

    int c_planowany_SK_zapasow;


}; /*KONIEC CIAŁA KLASY*/


int main()

{

    //zmienne do podania

    int zapas_dostepny_koniec_tyg,prognozowany_popyt,zamowienia_zarezerwowane,nadrzedny_plan_produkcji;

    cout<<"Podaj zapas dostępny na koniec tygodnia -> ";

    cin>>zapas_dostepny_koniec_tyg;

    cout<<"Podaj prognozowany popyt-> ";

    cin>>prognozowany_popyt;

    cout<<"Podaj zarezerwowane zamówienia -> ";

    cin>>zamowienia_zarezerwowane;

    cout<<"Podaj nadrzedny plan produkcji -> ";

    cin>>nadrzedny_plan_produkcji;

    plan *jeden=new plan(zapas_dostepny_koniec_tyg,prognozowany_popyt,zamowienia_zarezerwowane,nadrzedny_plan_produkcji);

    system("clear");

    jeden->zwroc_dane();

    delete jeden;

    jeden=0;

    return 0;

}

napisałem takie proste coś, które potem zamierzam rozszerzyć w miarę jak będę dochodziły mi nowe informacje na wykładach oraz zamierzam rozszerzyć go o liczenie danych dla okresu czasu z jakiegoś przedziału itp. itd. , ale mniejsza o to programik ma liczyć Planowany Stan Końcowy Zapasów, postanowiłem to zrobić na klasach głównie po to, żeby móc trenować i o co mi teraz chodzi 1. w konstruktorze domyślnym jako argumenty ustawiłem referencję do zmiennych zadeklarowanych w main żeby uniknąć tworzenie zbędnych mi kopii, czy zrobiłem to poprawnie ? 2. w funkcji zwroc_wieksza jako referencję przekazałem dwie zmienne składowe klasy, również aby uniknąć tworzenia zbędnej kopii na stosie, czy poprawnie ? 3. a teraz coś co mnie dziwi i nie umiem znaleźć na to odpowiedzi, czemu ten kawałek poprawnie liczy, to co mi jest potrzebne, czyli stan końcowy zapasów ?

void oblicz_SK_zapasow()

    {

        c_planowany_SK_zapasow=c_zapas_dostepny_koniec_tyg+c_nadrzedny_plan_produkcji-zwroc_wieksza(c_prognozowany_popyt,c_zamowienia_zarezerwowane);

    }
  1. ideą moją było żeby ogólnie wszystkie funkcje tutaj pracowały

a) koniecznie na referencjach jeśli chodzi o zmienne składowe

b) możliwie jeśli się na referencjach w przypadku zmiennych spoza klasy

czy dobrze ?

pytania które zadaję są z pewnością trochę głupie, ale nie chciałbym się nauczyć robić czegoś źle i potem nieustannie powielać tego błędu

AD 1. Nierozsądnie, bo referencja to tak naprawdę trochę inny wskaźnik (a wskaźnik ma ten sam rozmiar, co int). Pojawia się dodatkowy koszt dereferencji. Poza tym, co oznacza ten const przed int?

AD 2. j.w, poza tym od tego masz klasę, żebyś mógł pisać metody dla niej - a nie funkcje w ciele, które pobierają argumenty z tego samego obiektu.

AD 4. a) jeśli przekazywałbyś duży obiekt, np. vector, mapę czy coś swojego, to const referencja jest wskazana - ale nie int

AD 1. czyli, mówisz, żeby jeśli już robię to w konstruktorze przekazywać te zmienne z main przez wartość ?

> jeśli chodzi Ci o

const int zwroc_wieksza

to jest tutaj const ponieważ ta funkcja ma jedynie coś zwracać a nie zmieniać nic i jest to takie zabezpieczenie przed zmianą danych składowych (powołuję się tutaj na ‘C++ dla każdego’)

AD2. mógłbyś rozwinąć trochę ten wątek ?

AD4 a) czyli w przypadku poszczególnych zmiennych składowych, referencja nie jest wymaga ?

Tak.

Niekoniecznie, zobacz sobie taki kod:

#include 

using namespace std;


class Foo {

private:

  int a;

public:

  int get_a() { return a; }


  /* jak widac const nie chroni a */

  const int zmien_a1(int nowe_a)

  {

    a = nowe_a;

    return a;

  }


  /* tutaj juz tak (powinien byc wblad przy kompilacji) */

  int zmien_a2(int nowe_a) const

  {

    a = nowe_a;

    return a;

  }


};


int main()

{

  Foo f;

  int a;


  a = f.zmien_a1(10);

  cout << f.get_a();


  return 0;

}

Moim zdaniem zwroc_wieksza nie powinno przyjmować żadnych argumentów, bo i tak ma do nich dostęp (jest metodą).

Tak, są widoczne wewnątrz klasy. Można też się do nich dostać przez specjalny wskaźnik this, np. w powyższym zamiast ‘a’ pisać ‘this->a’. Musisz odróżniać metodę od funkcji.

dobrze, że zwróciłeś na to uwagę, ponieważ mam chyba tutaj problem, reasumując z książki nie zrozumiałem chyba, jak mniemam, ISTOTNEJ różnicy, mógłbyś wyjaśnić ?

co do problemu z const -> mam rozumieć, że w złym miejscu dałem const ? bo const przed deklaracją funkcji powoduje, że to co zwraca funkcja jest const, a const po już robi co innego ? bo jeśli tak, to wydawało mi się, że postawienie const w dowolnym miejscu daje ten sam efekt ?

?? Ja widzę tylko, że argumenty nazwałeś tak samo, jak zmienne w main (ad. 1) / pola klasy (ad. 2). Co daje jedynie taki skutek, że w drugim przypadku zasłoniłeś nazwy pól przez nazwy argumentów.

Zmienne wbudowanych typów i wyliczenia przekazuje się raczej przez wartość jeśli nie ma potrzeby ich modyfikacji. Natomiast przez referencje przekazuje się obiekty klas – bo zazwyczaj koszt przesłania referencji jest mniejszy niż koszt skopiowania całego obiektu.

Jeśli chcesz mieć stałą metodę, to słowo kluczowe const pojawia się na końcu:

void Class::fun() const { ... }
#include 

#include 

#include 


using namespace std;


class plan

{

public:

	plan()

	{

		c_planowany_SK_zapasow=0; //w konstruktorze domyślnym domyślnie przypisuje 0 do planowanego stanu zapasów

        oblicz_SK_zapasow();

		}

    ~plan()

    {

        //

    }


	void pobierz_zapas_dostepny_tyg_N_1(int zapas_dostepny_koniec_tyg) //metoda pobierająca zapas dostępny na koniec poprzedniego tygodnia

	{ //poprzedniego planu

		c_zapas_dostepny_koniec_tyg_N_1=zapas_dostepny_koniec_tyg; //metoda pobierająca prognozowany popyt na bieżacy tydzień

		}

	void pobierz_prognozowany_popyt(int prognozowany_popyt) //metoda pobierająca prognozowany popyt

	{

		c_prognozowany_popyt=prognozowany_popyt;

		}

	void pobierz_zamowienia_zarezerwowane(int zamowienia_zarezerwowane) //metoda pobierająca zamówienie zarezerwowane

	{

		c_zamowienia_zarezerwowane=zamowienia_zarezerwowane;

		}

	void pobierz_nadrzedny_plan_produkcji(int nadrzedny_plan_produkcji) //metoda pobierająca nadrzędny plan produkcji

	{

		c_nadrzedny_plan_produkcji=nadrzedny_plan_produkcji;

		}


    void zwroc_dane() const //stała metoda

    {

        cout<<"Zapas dostępny na koniec tygodnia = "<
        cout<<"Prognozowany popyt = "<
        cout<<"Zamówienie zarezerwowane = "<
        cout<<"Nadrzędny plan produkcji = "<
        cout<<"Planowany stan końcowy zapasów w danym tygodniu = "<
    }


    void oblicz_SK_zapasow()

    {

        c_planowany_SK_zapasow=c_zapas_dostepny_koniec_tyg_N_1+c_nadrzedny_plan_produkcji-zwroc_maks();

    }


    int zwroc_maks() const //stała metoda

    {

        if (c_zamowienia_zarezerwowane>c_prognozowany_popyt)

        {

            return c_zamowienia_zarezerwowane;

        }

        else

        {

            return c_prognozowany_popyt;

        }

    }

private:

    //zmienne do podania

    int c_zapas_dostepny_koniec_tyg_N_1; //0-wiersz

    int c_prognozowany_popyt; //1-wiersz

    int c_zamowienia_zarezerwowane; //2-wiersz

    int c_nadrzedny_plan_produkcji; //3-wiersz

    //zmienne do obliczenia

    int c_planowany_SK_zapasow; //4-wiersz

};


int main()

{

								//deklarowanie zmiennych

	int N; //rozmiar okres danych

	const int M=5; //rozmiar -> ilosc wierszych

	int zapas_dostepny_koniec_N_1_tyg,prognozowany_popyt,zamowienia_zarezerwowany,nadrzedny_plan_produkcji;


	cout<<"Podaj okres dla którego chcesz policzyć stany końcowe zapasów od 0 tygodnia do N-tego"<
	cin>>N;

	cout<<"Policze stany końcowego zapasów dla "<
	plan *okres[M][N];

	for(int i=0;i wiersze

	{

		for(int j=0;j kolumny, tj. konkretne okresy

		{

		plan *wskaznik_temp;

		wskaznik_temp=new plan;

		okres[i][j]=wskaznik_temp;

			if(i==0)

			{

				cout<<"Podaj zapas dostępny na koniec "<
				cin>>zapas_dostepny_koniec_N_1_tyg;

				okres[i][j]->pobierz_zapas_dostepny_tyg_N_1(zapas_dostepny_koniec_N_1_tyg);

				}

			else if(i==1)

			{

				cout<<"Podaj prognozowany popyt na "<
				cin>>prognozowany_popyt;

				okres[i][j]->pobierz_prognozowany_popyt(prognozowany_popyt);

				}

			else if(i==2)

			{

				cout<<"Podaj zamówienie zerezerwowane na "<
				cin>>zamowienia_zarezerwowany;

				okres[i][j]->pobierz_zamowienia_zarezerwowane(zamowienia_zarezerwowany);

				}

			else if(i==3)

			{

				cout<<"Podaj nadrzędny plan produkcji na "<
				cin>>nadrzedny_plan_produkcji;

				okres[i][j]->pobierz_nadrzedny_plan_produkcji(nadrzedny_plan_produkcji);

				}

			delete wskaznik_temp; wskaznik_temp=0; //newralgiczna linia 1

			}

	}

	delete [][] okres; //newralgiczna linia 2

}

mam problem, tworzę tablicę wskaźników do obiektów mojej klasy, ale mam problem z usunięciem jej w linii 2, ktoś może mi podpowiedzieć jak to poprawnie zrobić ? tablicę tworzę na podstawie opisu z “C++ dla każdego”

// Listing 13.6 - Tablica wskaźników do obiektów

#include 

using namespace std;

class CAT

{

public:

    CAT() { itsAge = 1; itsWeight=5; }

    ~CAT() {} // destruktor

    int GetAge() const { return itsAge; }

    int GetWeight() const { return itsWeight; }

    void SetAge(int age) { itsAge = age; }

private:

    int itsAge;

    int itsWeight;

};

int main()

{

    CAT * Family[500];

    int i;

    CAT * pCat;

    for (i = 0; i < 500; i++)

    {

         pCat = new CAT;

         pCat->SetAge(2*i +1);

         Family[i] = pCat;

    }

    for (i = 0; i < 500; i++)

    {

         cout << "Kot nr " << i+1 << ": ";

         cout << Family[i]->GetAge() << endl;

    }

    return 0;

}

Nie istnieje coś takiego jak delete[][]. Istnieją delete i delete[], każde z nich ma swoje użycie. delete służy do dealokacji obiektów zaalokowanych przez new (np. new int), a delete[] dealokacji tablic zaalokowanych przez new (np. new int[100]). To wszystko. Oczywiście nie możesz też zwalniać operatorem delete[] czegoś, co jest na stosie (tablica okres). Aha i tablica okres nie powinna być dynamiczna (standard zabrania) - dynamiczne tablice tworzysz za pomocą new.

Poczytaj: http://www.parashift.com/c+±faq-lite/freestore-mgmt.html

Wracając do const correctness, zobacz też: http://www.parashift.com/c+±faq-lite/const-correctness.html

Polecam to FAQ, odpowiada na sporo pytań, jakie może mieć początkujący.

dość skomplikowane jest dynamicznie alokowanie dwuwymiarowych tablic :confused:

A musisz używać dwuwymiarowych?

Na przykład dla klasy Macierz wystarczą składowe:

unsigned Rows,Cols;

double *Tab;

przydzielasz pamięć: Tab=new double[Rows*Cols];

komórka x,y: Tab[y*Cols+x]

Dla adresacji można przeciążyć nawiasy okrągłe:

double &operator()(unsigned y,unsigned x) { return Tab[y*Cols+x]; }

const double &operator()(unsigned y,unsigned x)const { return Tab[y*Cols+x]; }

(nie zapomnieć o kontroli zakresu)

korzystanie będzie podobne do basica :smiley:

Macierz M(5,5);

M(0,0)=3.5;

No chyba że koniecznie chcesz mieć adresacje przez nawiasy kwadratowe, wtedy najprościej przez dodatkową klasę wewnętrzną.

Ewentualnie jeżeli chcesz znaleźć dla Tab[pos] który to wiersz i kolumna: y=pos/Cols; x=pos%Cols;

Całą dwuwymiarowość może załatwić klasa.

#include 

#include 

#include 


using namespace std;


class plan

{

public:

    plan(int W, int K) //konstruktor w którym następuje tworzenie dynamicznej tablicy przechowującej dane

    {

        cout<<"Konstruktor"<
        c_W=W;

        c_K=K;

        c_okres=new int*[c_W];

        for (w_i=0;w_i
        {

            c_okres[w_i]=new int[c_K];

        }

        pobieraj_dane();

    }

    ~plan() //dekonstruktor będzie usuwał zadeklarowaną w konstruktorze tablicę

    {

        cout<<"Destruktor"<
        for (int i=0;i
        {

            delete [] c_okres[i];

        }

        delete c_okres;

    }


    void pobieraj_dane()

    {

        for (w_k=0;w_k
        {

            cout<
            static short int licznik=0;

            if (licznik==0)

            {

                cout<<" Podaj zapas dostępny na koniec "<";

                cin>>c_zapas_dostepny_koniec_tyg;

                c_okres[0][w_k]=c_zapas_dostepny_koniec_tyg;

                licznik++;

            }


            cout<<" Podaj prognozowany popyt dla "<";

            cin>>c_prognozowany_popyt;

            c_okres[1][w_k]=c_prognozowany_popyt;


            cout<<" Podaj zamówienia zerezerwowane dla "<";

            cin>>c_zamowienia_zarezerwowane;

            c_okres[2][w_k]=c_zamowienia_zarezerwowane;


            cout<<" Podaj nadrzędny plan produkcji dla "<";

            cin>>c_nadrzedny_plan_produkcji;

            c_okres[3][w_k]=c_nadrzedny_plan_produkcji;

            system("clear");

        }

        obliczenie_planowanego_stanu_zapasow();

        obliczenie_zapasow_do_rozdysponowania();

    }


    void obliczenie_planowanego_stanu_zapasow()

    {

        for (w_k=0;w_k
        {

            if (c_okres[1][w_k]>c_okres[2][w_k])

            {

                c_okres[4][w_k]=c_okres[0][w_k]+c_okres[3][w_k]-c_okres[1][w_k];

            }

            else

            {

                c_okres[4][w_k]=c_okres[0][w_k]+c_okres[3][w_k]-c_okres[2][w_k];

            }

            c_okres[0][w_k+1]=c_okres[4][w_k];

        }

        wypisz_dane();

    }


    void obliczenie_zapasow_do_rozdysponowania() //ten fragment jeszcze nie działa poprawnie!

    {

    }


    void wypisz_dane()

    {

        system("clear");

        for (w_k=0;w_k
        {

            cout<
            cout<<"Zapas dostępny w "<
    cout <<"Ilość tygodni ->";

    cin>>K;

    plan *nowy=new plan(W,K);

    delete nowy;

    nowy=0;

    return 0;

}[/code]

problem z dynamiczną alokacją rozwiązałem w konstruktorze, za radę kolegi z kierunku informatyka :),

teraz jak jest to już napisane, niekompletne, ale to akurat problem na później, to może jakieś sugestie na przyszłość, co jest tutaj nieprawidłowe, czy jest w programie jakaś “bomba z opóźnionym zapłonem”, co się nie zgadza z jakimiś utartymi schematami, czy coś można zrobić lepiej i szybciej ?

sugestie i konstruktywna krytyka mile widziane :slight_smile:

Skoro w klasie nigdzie nie masz indeksowanego odwołania do pierwszego wymiaru tablicy c_okres to na 100% nie potrzebujesz tablicy dwuwymiarowej tylko jednowymiarowej tablicy struktur:

struct dane { int zapas,popyt,rezerwa,plan,stan; } *c_okres;

Przydzielasz pamięć na W wierszy (parametr konstruktora) nigdzie nie sprawdzasz czy ta W jest większa od 5. A w metodach używasz wierszy z indeksami 0…5 - aż się prosisz o “segmentation fault”.

Deklaracja zmiennych potrzebnych tylko lokalnie jako składowych klasy zupełnie mija się z celem.

Zamiast wielkich konstrukcji w stylu:

            if (c_okres[1][w_k]>c_okres[2][w_k])

a poprawnie byłoby jakbym wywoływał klasę tylko z parametrem K (kolumny - okres czasu), a parametr W (wiersze) umieścił jako stały w konstruktorze klasy ? - pytanie teoretyczne

a mija się z celem ponieważ operuje jedynie na komórkach swojej tablicy i mógłbym bezpośrednio do niej zapisywać dane ?

czyli wiem co mnie czeka w ver0.2 ;-), ale teraz bardziej poważnie…

czemu mówisz, że nie mam nigdzie odwołania do pierwszego wymiaru tablicy

static short int licznik=0;

            if (licznik==0)

            {

                cout<<" Podaj zapas dostępny na koniec "<";

                cin>>c_zapas_dostepny_koniec_tyg;

                c_okres[0][w_k]=c_zapas_dostepny_koniec_tyg;

                licznik++;

            }

w tym miejscu tylko i wyłącznie jeden raz odwołuję się i wypełniam element [0][0], chyba że nie o to Ci chodziło ?

co do braku potrzeby posiadania dwuwymiarowej tablicy, a struktury, to się zajmę tym zagadnieniem w najbliższym czasie

masz odwołania:

c_okres[0][x],c_okres[1][x],c_okres[2][x],c_okres[3][x],c_okres[4][x],c_okres[5][x]

nie masz odwołań:

c_okres[y][x]

ze zmiennymi lokalnymi chodziło mi o:

for(int i=0;i

zamiast:

for (w_k=0;w_k

int w_k; // w_k - składowa

oraz:

cout<<" Podaj zapas dostępny na koniec “<”;

cin>>c_okres[0][w_k];

deklaracje zmiennej składowej:

c_zapas_dostepny_koniec_tyg;

tylko po to aby w jednej z metod użyć to jako zmienną tymczasową to bezsens.

Właściwie zamiast tablicy potrzebujesz listę dwukierunkową klas.

Wprowadzanie danych w metodzie klasy, komunikaty na ekran w metodach klasy, właściwie nie masz ani jednego fragmentu zrobionego ideologicznie poprawnie. Może poczytaj trochę o programowaniu OOP (ang. object-oriented programming).

czytam ze spuszczoną głową, ale się pocieszam, że nie od razu Rzym zbudowali, będę szukał i czytał

przynajmniej wiem, teraz mniej więcej na co zwracać uwagę, bom samouk :slight_smile:

Dodane Wt mar 16, 2010 1:48 am

poczytałem trochę mam kilka świeżych pomysłów i będę starał się je wprowadzić mam nadzieję poprawnie w życie

wpierw kody

main.cpp

#include 

#include 

#include "plan.h"


using namespace std;


int main()

{

    /*deklarowanie zmiennych*/

    static short int okres=0; //

    short int i=0; //zmienna do obsługi pętli

    /*koniec->deklarowania zmiennych*/


    cout<<"Plan nadrzedny logistyka"<
    cout<<"Podaj okres w tygodniach dla ktorego chcesz wykonac plan nadrzedny"<
    cout<<"Okres danych ->"; cin>>okres;


    //kawałek tworzacy_zadana_ilosc_obiektow_klasy_PLAN

    plan_nadrzedny *tablica_obiektow[okres];

    plan_nadrzedny *temp;


    for(i;i
    {

	cout<<"Tworze obiekt dla "<
	temp=new plan_nadrzedny;

	tablica_obiektow[i]=temp;

    }

    for(i=0;i
    {

	delete tablica_obiektow[i];

    }

    *tablica_obiektow=0;

    //

    return 0;

}

[/code]




plan.h

[code]#ifndef PLAN_H #define PLAN_H /*deklaracja zapowiadająca klasy*/ class plan_nadrzedny; class dane; class plan_nadrzedny { public: plan_nadrzedny(); virtual ~plan_nadrzedny(); //metody klasy plan_nadrzedny void c_pobierz_dane_ustaw_dane(); //pobiera i ustawia dane w klasie dane void c_oblicz(); //oblicza potrzebne zmienne void c_zwroc_dane(); //zwraca dane pobierając je z klasy dane protected: dane *obiekt_dane; //tworzę wskaźnik na obiekt dane, który ma przechowywać dane }; class dane { public: dane(); ~dane(); protected: int *c_stan_zapasow_tydzien_poprzedni; int *c_planowany_popyt; int *c_zamowienia_zarezerwone; int *c_planowany_sk_zapasow; int *c_nadrzedny_plan_produkcji; int *c_dostepne_do_rozdysponowania; }; #endif // PLAN_H
plan.cpp

#include "plan.h"

#include 

using namespace std;


plan_nadrzedny::plan_nadrzedny() //konstruktor

{

    cout<<"Konstruktor klasy plan_nadrzedny"<
    dane *obiekt_dane=new dane;

}

plan_nadrzedny::~plan_nadrzedny() //destruktor

{

    cout<<"Destruktor klasy plan_nadrzedny"<
    delete obiekt_dane;

    obiekt_dane=0;

}


////////////////////////////////////////////////////////////


dane::dane() //konstruktor

{

    cout<<"Konstruktor klasy dany"< obiekt jest tworzony

    c_stan_zapasow_tydzien_poprzedni=new int;

    c_planowany_popyt=new int;

    c_zamowienia_zarezerwone=new int;

    c_planowany_sk_zapasow=new int;

    c_nadrzedny_plan_produkcji=new int;

    c_dostepne_do_rozdysponowania=new int;

}


dane::~dane() //destruktor

{

    cout<<"Destruktor klasy dane"< mimo usunięcia obiektu plan_nadrzedny nie usuwa sie obiekt dane ?

    delete c_stan_zapasow_tydzien_poprzedni;

    delete c_planowany_popyt;

    delete c_zamowienia_zarezerwone;

    delete c_planowany_sk_zapasow;

    delete c_nadrzedny_plan_produkcji;

    delete c_dostepne_do_rozdysponowania;

}

od czego by tu zacząć, a no primo

w plan.cpp mam linijkę

przykładowy output pokazuje, że w trakcie tworzenia pętli znajduję się odpowiednie w konstruktorze klasy plan_nadrzedny jak i klasy dane , ale później przy usuwaniu jestem już tylko w destruktorze klasy plan_nadrzedny wychodzi na to, że obiekt klasy dane nie jest usuwany z pamięci ?

gdzie leży tego przyczyna ?

próbowałem zrobić z klasy dane klasę pochodną z klasy plan_nadrzedny, ale dostałem tylko niekończącą się pętlę

pytanie drugie -> czy nie popełniam jakiegoś błędu takiego jak przytaczane wcześniej, starałem się uważam, ale kto wie, czy znowu nie wpadłam na jakiś “genialny inaczej” pomysł

Jeszcze większy bezsens :smiley:

Poco składowe klasy dane przydzielać dynamicznie?

Wystarczy:

struct dane{    int c_stan_zapasow_tydzien_poprzedni;    int c_planowany_popyt;    int c_zamowienia_zarezerwone;    int c_planowany_sk_zapasow;    int c_nadrzedny_plan_produkcji;    int c_dostepne_do_rozdysponowania;  }; [/code]

Ale na ile dobrze rozumiem c_stan_zapasow_tydzien_poprzedni=poprzedni.c_dostepne_do_rozdysponowania, w takim razie miało by sens:


[code=php]class dane{    public:    int c_stan_zapasow_tydzien_poprzedni;    int c_planowany_popyt;    int c_zamowienia_zarezerwone;    int c_planowany_sk_zapasow;    int c_nadrzedny_plan_produkcji;    int c_dostepne_do_rozdysponowania;    dane(int stan_zapasow):c_stan_zapasow_tydzien_poprzedni(stan_zapasow) {}  }; 

Więc w klasie Plan robisz składową stan_zapasow i dane na pierwszy tydzień będą referować na tą składową, zaś każda następna będzie referować na c_dostepne_do_rozdysponowania z poprzedniego tygodnia.



Może jednak prościej będzie zrobić to za pomocą listy dwukierunkowej:



class Stan{   public:   int c_dostepne_do_rozdysponowania;   Stan *nastepny;   Stan(int stan_zapasow=0):c_dostepne_do_rozdysponowania(stan_zapasow),nastepny(0) {}   ~Stan() {}  };class Tydzien:public Stan{   public:   int c_planowany_popyt;   int c_zamowienia_zarezerwone;   int c_planowany_sk_zapasow;   int c_nadrzedny_plan_produkcji;   Stan *poprzedni;   int stan_zapasow_tydzien_poprzedni()const { return poprzedni-c_dostepne_do_rozdysponowania; }   Tydzien(Stan *poprzedni):poprzedni(poprzedni) { poprzedni-nastepny=this; }   void oblicz() { ... }  };class Plan:public Stan{   public:   Stan *ostatni;   Plan(int stan_zapasow):Stan(stan_zapasow),ostatni(this) {}   ~Plan()     {      while(nastepny)        {         Stan *tmp=nastepny;         nastepny=tmp-nastepny;         delete tmp;        }     }   Tydzien Dodaj(int popyt, ... )     {      Tydzien *tmp=new Tydzien(ostatni);      tmp-c_planowany_popyt=popyt;      ...      tmp-oblicz();      ostatni=tmp;      return *tmp;     }  }; [/code]Pisałem wprost tu bez kompilatora, więc potraktuj to raczej jako schemat a nie jako rozwiązanie.

nie wiem :D, to było akurat w pełni zasłużona krytyka :smiley:

nie to nie jest to samo :), ale to nie jest takie ważne

dane(int &stan_zapasow):c_stan_zapasow_tydzien_poprzedni(stan_zapasow) {}

to oznacza ten zapis ?, dobrze jest do funkcja przyjmująca jako parametr referencję do stan_zapasów, ale jak interpretuje się ten kawałek dalej ?

To jest konstruktor z listą inicjalizacyjną, możesz to czytać następująco:

dane(int &stan_zapasow)

normalnie czuję, że mnie to przerosło chyba

Którego wiersza nie rozumiesz? :lol: