C++ inicializacja tablicy w klasie.

Cześć,

zastanawiam się czy można rozwiązać mój problem w inny sposób, bardziej "elegancki". Chodzi o to, że mam klase abstrakcyjna X i dwie klasy które po niej dziedzicza Y i Z.
Każda z klas Y i Z powinna posiadać inną inicjalizację tej tablicy.

W tym przypadku ktoś zrobił to poprzez przekazanie pointera na statyczną tablicę.
Dodam, że w tym przypadku raczej odpada systuacja statycznej tablicy.

class AbstractX()
{
protected:
     int* x;
     int *y;
public:

    virtual void setPointers();
}

class Y() : public AbstractX
{
private:
    int* array;
    
public:
    void initializeArray()
    {
        static int staticArray[]
        {
            jakie dane w array, które m.in posiadają rzeczy z pointera x,y (z klasy abstract).
        }
        array = staticArray;
    }
    
    int* getArrray()
    {
        return array;
    }
}

class Z() : public AbstractX
{
private:
    int* array;

public:
    void initializeArray()
    {
        static int staticArray[]
        {
            jakie dane w array, które m.in posiadają rzeczy z pointera x,y (z klasy abstract).
            INNE NIZ W klasie Y.
        }
        array = staticArray;
    }
    
    int* getArrray()
    {
        return array;
    }
}

Nic tu nie jest eleganckie.
Od dziedziczenia protected danych, przez szemrane zamienniki konstruktorów, a brak tychże ...

Jaki jest PRAWDZIWY problem, który chcesz zaimplementować / rozwiązać?

@AnyKtokolwiek: to jest pseudo kod, nie czepiaj sie ze nie ma konstruktorow, bo w oryginale normalnie sa. Nie to jest tematem tego postu.

btw. co zlego w dziedziczneiu protected ??

Chce mięć tablicę w obu klasach Y i Z. W inicjalizacji tablicy będzie odwoływanie się do właśnie pól protected.
Bo te pola w protected są takie same dla obu klas. Tylko kazda z tych klas przypisuje do nich inne wartości.

Napis to w mniej "pseudo", a w szczególności jakiś masz pomysł na konstruktory?

@AnyKtokolwiek: Pomiń temat konstruktorów. Chodzi mi tylko o kwestie inicjalizacji tablicy. Ale widzę, że kompletnie nie wiesz o co chodzi xD Więc obawiam się, że nie będziesz mi mógł pomóc.

Co musi być w konstruktorach? Serio nie wiem o co Ci chodzi.

belzebub269 napisał(a):

@AnyKtokolwiek: Pomiń temat konstruktorów. Chodzi mi tylko o kwestie inicjalizacji tablicy. Ale widzę, że kompletnie nie wiesz o co chodzi xD Więc obawiam się, że nie będziesz mi mógł pomóc.

Nie da się mówić o inicjacji bez rozmowy o konstruktorach. W szczególności bez konstrukra przodka nie da się okreslić wartości wskazników

class AbstractX
{
    protected:
    int *x,*y;
    public:
    virtual int *getArrray();
}

class Y:public AbstractX
{
	public:
    virtual int *getArrray()
    {
        static int ret[]
        {
            jakie dane w array, które m.in posiadają rzeczy z pointera x,y (z klasy abstract).
        };
        return ret;
    }
}

@AnyKtokolwiek: Pointery są inicjalizowana za pomocą metody z klasy AbstractX.

a dlaczego initializeArray() nie jest w klasie nadrzędnej jako virtual?

belzebub269 napisał(a):

@AnyKtokolwiek: Pointery są inicjalizowana za pomocą metody z klasy AbstractX.

Wytłumacz co dokładnie chcesz zrobić, bo brzmi paskudnie.

@Miang: jest, zapomnialem dodać. Nie wiedzialem, ze bedziecie sie skupiac na rzeczach, ktore tutja W OGOLE nie maja znaczenia...

@_13th_Dragon: @Miang: @AnyKtokolwiek:

class AbstractX()
{
protected:
     int* x;
     int *y;
public:

    virtual void setPointers(int* x, int* y)
    {
        this.x=x;
        this.y=y;
    }
    virtual void initializeArray() = 0;
    virtual void int* getArrray() = 0;
}

class Y() : public AbstractX
{
private:
    int* array;
    
public:
    void initializeArray()
    {
        static int staticArray[]
        {
            jakie dane w array, które m.in posiadają rzeczy z pointera x,y (z klasy abstract).
        }
        array = staticArray;
    }
    
    int* getArrray()
    {
        return array;
    }
}

class Z() : public AbstractX
{
private:
    int* array;

public:
    void initializeArray()
    {
        static int staticArray[]
        {
            jakie dane w array, które m.in posiadają rzeczy z pointera x,y (z klasy abstract).
            INNE NIZ W klasie Y.
        }
        array = staticArray;
    }
    
    int* getArrray()
    {
        return array;
    }
}

belzebub269 napisał(a):

@Miang: jest, zapomnialem dodać. Nie wiedzialem, ze bedziecie sie skupiac na rzeczach, ktore tutja W OGOLE nie maja znaczenia...

Przejawiasz typowe symptomy problemu XY. Masz jakieś swoje dziwne rozwiązanie dziwnego problemu, a na pytanie o ogólny zarys, aby uzasadnić istnienie problemu w ogóle, reagujesz agresywnie jak ta pani z It's Not About The Nail.

Nie mamy zielonego pojęcia (bo odmówiłeś udzielenia odpowiedzi) co to jest za problem, nie wiem czy może być kolejna klasa, która może w tym wypadku oczekiwać jeszcze innych danych, nie wiem czym są x i y i po co są w klasie bazowej. Nie wiemy de facto nic, ale oczekujesz konkretnych odpowiedzi...

@kq: Czy pytanie o sposób inicjalizacji tablicy to jest na prawdę dziwny problem?!

Nie będzie kolejnych klas, gdyby były to na pewno bym o tym wspomniał.

X i Y w tablicy bazowej są to pointery na konkretny obszar w pamięci gdzie znajdują się interesujące nas dane.
Są w klasie bazowej tylko dlatego, że dla obu klas dziedziczącej pointery są takie same (wskazują na ten sam obszar pamięci).

W klasach dziedziczących inicjalizowane będą tablice, które będą wykorzystywały DANE które znajdują się właśnie pod pointerami X i Y.

Tablice w klasach Y i Z będą różniły się inicjalizacją, ale będą mimo wszystko bazowały na tych samych pointerach X i Y.

Coś mogę jeszcze doprecyzować?

@belzebub269:

belzebub269 napisał(a):

@kq: Czy pytanie o sposób inicjalizacji tablicy to jest na prawdę dziwny problem?!

Coś mogę jeszcze doprecyzować?

Czemu nie zrobić int *x,*y w każdej z tych klas pochodnych?
Po raz trzeci ignorujesz pytanie co int *x,*y mają do int *array.

@_13th_Dragon: po co powielać te same pointery w klasach i ich inicjalizację? pytam, bo może bez zasadnie wrzuciłem je do klasy bazowej.

Wskaźniki X i Y wskazują na DANE, które wykorzystywane są w tablicy array. Nie wiem jak inaczej mogę to wytlumaczyć.

#include <vector>
using namespace std;

class AbstractXYZ
{
	public:
	enum Kind {akX,akZ};
	AbstractXYZ(Kind kind):kind(kind),px(0),py(1) {}
	protected:
    Kind kind;
    int px,py;
	public:
    vector<int> &array()const
    {
    	static vector<vector<int>> arr
		{
			//akX
			{
			    0,1,2,3,4,5,
			},
			//akZ
			{
			    9,8,7,6,
			},
		};
		return arr[kind];
    }
    void iterate()
    {
    	vector<int> &arr=array();
    	for(int y=0;y<arr.size();++y)
    	{
	    	for(int x=0;x<arr.size();++x)
	    	{
	    		if(true) //
	    		{
	    			px=x;
	    			py=y;
	    			return;
	    		}
	    	}
    	}
    }
    int getX()const { return array()[px]; }
    int getY()const { return array()[py]; }
};

X i Y w tablicy bazowej są to pointery na konkretny obszar w pamięci gdzie znajdują się interesujące nas dane.
Są w klasie bazowej tylko dlatego, że dla obu klas dziedziczącej pointery są takie same (wskazują na ten sam obszar pamięci).

W klasach dziedziczących inicjalizowane będą tablice, które będą wykorzystywały DANE które znajdują się właśnie pod pointerami X i Y.

Tablice w klasach Y i Z będą różniły się inicjalizacją, ale będą mimo wszystko bazowały na tych samych pointerach X i Y.

Coś mogę jeszcze doprecyzować?

Nadal opisujesz X, gdy ja pytam o Y.

Czy pytanie o sposób inicjalizacji tablicy to jest na prawdę dziwny problem?!

Tak, gdy zadajesz je w kontekście oderwanego od rzeczywistości przykładu. Szczególnie, że ciężko nawet stwierdzić o jaką inicjalizację pytasz, a najbardziej bezpośrednia odpowiedź jest taka:
Inicjalizacja tablicy wygląda następująco:

typ nazwa[] = { /* dane */ };

Nie będzie kolejnych klas, gdyby były to na pewno bym o tym wspomniał.

Mieliśmy się tego domyślić? Jeśli przewidujesz hierarchię dziedziczenia to właśnie po to, aby pozostała otwarta. Skoro robisz odwrotnie to może warto zastanowić się dlaczego idziesz pod prąd?

Są w klasie bazowej tylko dlatego, że dla obu klas dziedziczącej pointery są takie same (wskazują na ten sam obszar pamięci).

Dlaczego używasz tu dziedziczenia? Teraz mam wrażenie, że masz dwie niezależne od siebie klasy, które mają podobny kawałek implementacji i uznałeś że idealnym rozwiązaniem do tego będzie użycie dziedziczenia.

W klasach dziedziczących inicjalizowane będą tablice, które będą wykorzystywały DANE które znajdują się właśnie pod pointerami X i Y.

Czemu te klasy mają inicjalizować te tablice? Dlaczego nie inicjalizować po prostu wskaźników x i y? Po co w ogóle wskaźnik array w klasie, skoro wydajesz się wyłącznie zainteresowany x i y?

Jak dla mnie całe to rozwiązanie kupy się nie trzyma (wg obecnie dostępnych danych), nie wiadomo o co pytasz i dziwisz się, że dopytujemy o co właściwie chodzi.

Mieliśmy się tego domyślić? Jeśli przewidujesz hierarchię dziedziczenia to właśnie po to, aby pozostała otwarta. Skoro robisz odwrotnie to może warto zastanowić się dlaczego idziesz pod prąd?

Dlaczego używasz tu dziedziczenia? Teraz mam wrażenie, że masz dwie niezależne od siebie klasy, które mają podobny kawałek implementacji i uznałeś że idealnym rozwiązaniem do tego będzie użycie dziedziczenia.

Wykorzystuję tutaj dziedziczenie, bo jest mi potrzebne do polimorfizmu. W odrębnej klasie będę raz korzystał z klasy Y raz z klasy Z. W zależności od tego jaka inicjalizację tablicy będę potrzebował.

Czemu te klasy mają inicjalizować te tablice? Dlaczego nie inicjalizować po prostu wskaźników x i y? Po co w ogóle wskaźnik array w klasie, skoro wydajesz się wyłącznie zainteresowany x i y?

Wskaźniki X i Y muszą być zainicjalizowane, bo korzystam z nich potem w tablicach. Wskaźnik array pozwoli mi na dostanie się do zawartosci tablicy z klasy zewnętrznej.

Generalnie problem jest taki, ze potrzebuję wyeksportować ogromne dwie tablice X i Y (po 500-600 linijek) do zewnętrznych plików z powodu tego, że potrzebuje z tych tablic korzystać z różnych plików.

kq napisał(a):

belzebub269 napisał(a):

@Miang: jest, zapomnialem dodać. Nie wiedzialem, ze bedziecie sie skupiac na rzeczach, ktore tutja W OGOLE nie maja znaczenia...

Przejawiasz typowe symptomy problemu [XY][1]. Masz jakieś swoje dziwne rozwiązanie dziwnego problemu, a na pytanie o ogólny zarys, aby uzasadnić istnienie problemu w ogóle, reagujesz agresywnie jak ta pani z [It's Not About The Nail][2].

Nie mamy zielonego pojęcia (bo odmówiłeś udzielenia odpowiedzi) co to jest za problem, nie wiem czy może być kolejna klasa, która może w tym wypadku oczekiwać jeszcze innych danych, nie wiem czym są x i y i po co są w klasie bazowej. Nie wiemy de facto nic, ale oczekujesz konkretnych odpowiedzi...

Zamierzałem się dokładnie tymi samymi zdaniami wypowiedzieć. Łącznie z psychologią.
Tak że wbrew zaleceniom, cytuję CAŁY post.

Cholera wie, jak zgadywać, jaka była ostatnia Twoja myśl @belzebub269 zanim kolejne poszły w krzaki.
W tej mgle wszystkie przypuszczenia są możliwe, a moim jest, że źle wybrałeś dziedziczenie w ogóle jako metodę, lub szczegóły dziedziczenia.

Tu patrzę na księżyc ... i zgaduję, ze to klasa w rodzaju Konfiguracja. Zachowuję oryginalne nazwy, choć już nie tworzą hierarchii

class AbstractX()  // konfiguracja
{
}


class Y {
   Y(const * AbstractX);
}

class X {
   X(const * AbstractX);
}

belzebub269 napisał(a):

Mieliśmy się tego domyślić? Jeśli przewidujesz hierarchię dziedziczenia to właśnie po to, aby pozostała otwarta. Skoro robisz odwrotnie to może warto zastanowić się dlaczego idziesz pod prąd?

Dlaczego używasz tu dziedziczenia? Teraz mam wrażenie, że masz dwie niezależne od siebie klasy, które mają podobny kawałek implementacji i uznałeś że idealnym rozwiązaniem do tego będzie użycie dziedziczenia.

Wykorzystuję tutaj dziedziczenie, bo jest mi potrzebne do polimorfizmu. W odrębnej klasie będę raz korzystał z klasy Y raz z klasy Z. W zależności od tego jaka inicjalizację tablicy będę potrzebował.

Czemu te klasy mają inicjalizować te tablice? Dlaczego nie inicjalizować po prostu wskaźników x i y? Po co w ogóle wskaźnik array w klasie, skoro wydajesz się wyłącznie zainteresowany x i y?

Wskaźniki X i Y muszą być zainicjalizowane, bo korzystam z nich potem w tablicach. Wskaźnik array pozwoli mi na dostanie się do zawartosci tablicy z klasy zewnętrznej.

Generalnie problem jest taki, ze potrzebuję wyeksportować ogromne dwie tablice X i Y (po 500-600 linijek) do zewnętrznych plików z powodu tego, że potrzebuje z tych tablic korzystać z różnych plików.

1. Sorry, ale odp ma wartość "używam widelca do zupy, bo potrzebuję widelca"
2. Swobodnie się za zaaranżować w/w eksport danych bez takich potworów. NIC, dosłownie NIC do takich chorych pomysłów anie nie zmusza, ani nie prowadzi.
   To naprawdę jest XY Problem, łącznie z Twoim uporem, rzucaniem krytyki na bzdurne porady i emocjami.

Zamiast emocji określ jak prawdziwy facet, jakie są zakresy odpowiedzialności tych klas (co robią), NAZWY itd.

belzebub269 napisał(a):

class AbstractX()
{
protected:
     int* x;
     int *y;
public:

    virtual void setPointers(int* x, int* y)
    {
        this.x=x;
        this.y=y;
    }
    virtual void initializeArray() = 0;
    virtual void int* getArrray() = 0;
}

[CIACH!]

Hmm. Niedasię. Z tym co pokazałeś, jedyne co możesz zrobić to array = this.x + <jakieś przesunięcie>; lub array = new int []; i kopiowanie kawałków spod *x, *y.
Chyba że będziesz zwracał inne struktury. Np: tablicę wskaźników na elementy/obszary. Tu też inicjacja będzie zależna od tego czy te zwracane obszary są zawsze w tych samych miejscach (coś jak w przykładzie @_13th_Dragon https://4programmers.net/Forum/C_i_C++/346258-c_inicializacja_tablicy_w_klasie?p=1725219#id1725219) czy też trzeba je wcześniej policzyć.

Opisz dokładniej co robisz.