[C++] Problem z macierzą wskaźnikową

[diskbit]

Jak zrobić poniższy przykład macierzy wskaźnikowej dwuwymiarowej bez funkcji switch

Kod: Zaznacz cały

    int arra_size_A = 5 ;
    int arra_size_B = 7 ;
    int **ptr ;
    int **ptr_Home ;
    int *ptr_HomeB ;

    int *ptr_Home00 ;
    int *ptr_Home01 ;
    int *ptr_Home02 ;
    int *ptr_Home03 ;
    int *ptr_Home04 ;


    ptr  = new int*[arra_size_A];
    ptr_Home=&*ptr;

    std::cout<< " example 1 - position 01 ***************************************** ";
    std::cout<<std::endl;

    ptr=&*(ptr_Home);
    for(int A = 0; A < arra_size_A; A++)
    {
        ptr[A] = new int[arra_size_B];
        switch( A )
        {
            case 0:
                ptr_Home00 = &*ptr[A];
                ptr_HomeB = ptr_Home00;
                break;
            case 1:
                ptr_Home01 = &*ptr[A];
                ptr_HomeB = ptr_Home01;
                break;
            case 2:
                ptr_Home02 = &*ptr[A];
                ptr_HomeB = ptr_Home02;
                break;
            case 3:
                ptr_Home03 = &*ptr[A];
                ptr_HomeB = ptr_Home03;
                break;
            case 4:
                ptr_Home04 = &*ptr[A];
                ptr_HomeB = ptr_Home04;
                break;
        }

        for(int B = 0; B < arra_size_B; B++)
        {
            int a = rand()%1000;
            *ptr[A]=a;
            std::cout<< " [ "<< A <<","<< B <<  "=" << *ptr[A] << " Adres = " << &*ptr[A]<< "  Agres Start B =" << ptr_HomeB <<" ] " ;
            ptr[A]++;
        }
        std::cout<<std::endl;
    }
    //==========================================================

    std::cout<< " example 1 -  positon 02 ***************************************** ";
    std::cout<<std::endl;

    ptr=&*(ptr_Home);
    for(int A = 0; A < arra_size_A; A++)
    {

        switch( A )
        {
            case 0:
                ptr[A] = &*ptr_Home00 ;
                ptr_HomeB = ptr_Home00;
                break;
            case 1:
                ptr[A] = &*ptr_Home01 ;
                ptr_HomeB = ptr_Home01;
                break;
            case 2:
                ptr[A] = &*ptr_Home02 ;
                ptr_HomeB = ptr_Home02;
                break;
            case 3:
                ptr[A] = &*ptr_Home03 ;
                ptr_HomeB = ptr_Home03;
                break;
            case 4:
                ptr[A] = &*ptr_Home04 ;
                ptr_HomeB = ptr_Home04;
                break;
        }

        for(int B = 0; B < arra_size_B; B++)
        {
            std::cout<< " [ "<< A <<","<< B <<  "=" << *ptr[A] << " Adres = " << &*ptr[A]<< "  Agres Start B =" << ptr_HomeB <<" ] " ;
            ptr[A]++;
        }
        std::cout<<std::endl;
    }

    //==========================================================
    ptr=&*(ptr_Home);
    delete[] ptr ;

[leg14]

Moze powiedz co chcesz osiagnac

[diskbit]

Nie wiem jak w tym konkretnym przypadku zastąpić funkcje switch , gdyż aktualnie macierz ta ma wymiar
int arra_size_A = 5 , czyli w/z tym mam aż 5 zmiennych ptr_Home00,ptr_Home01..ptr_Home04.
Jak macierz będzie miała wymiar arra_size_A = 1000 , to nie będę chyba deklarował tyle zmiennych aż do ptr_Home1000 . Potrzebny jest jakiś sposób aby , aby wrzucić to macierzy ale również wskaźnikowej .
Próbowałem ale bez powodzenia .

[leg14]

Ale ja pytam co tak naprawdę chcesz osiągnąć tym programem.
(taka mała uwaga &*ptr jest równoważne ptr)

[diskbit]

( &*ptr jest równoważne ptr)
Tak to prawda ale specjalnie użyłem całej gamy instrukcji i to tylko raz
dla ptr_Home=&*ptr; , aby mieś w zmiennej ptr_Home wartość wskaźnika początkowego .
W następnych liniach programu za jego pomocą ustawiam się na ptr=&*(ptr_Home);

[leg14]

la ptr_Home=&*ptr; , aby mieś w zmiennej ptr_Home wartość wskaźnika początkowego .
W następnych liniach programu za jego pomocą ustawiam się na ptr=&*(ptr_Home);

Kod: Zaznacz cały

ptr_Home=&*ptr;

ma ten sam efekt co

Kod: Zaznacz cały

ptr_Home=ptr;

[diskbit]

Tak to prawda ptr_Home=&*ptr; to jest to samo co ptr_Home=ptr; .
Ale to nie rozwiązuje mojego problemy .
Właściwie to potrzebował bym jednej informacji
Jak stworzyć macierz opartą na wskaźnikach w której mógłbym przechowywać dane o adresach ze zmiennych

Kod: Zaznacz cały

 array[0] to ptr_Home00 ,
 array[1] to ptr_Home01 ,
 array[2] to ptr_Home02 ,
 array[3] to ptr_Home03 ,
 array[4] to ptr_Home04 

i następnie jak z array wykonać
np: ptr[A] = ptr_Home04 ;
w taki sposób ptr[A]= array[4];

w kodzie coś takiego

Kod: Zaznacz cały

   int *array ;
   int *array_Home ;

    array  = new int[arra_size_A];

    array_Home = array ;

*array = &array_Home -> to się nie zapisuje , jest błąd ;

-- 16 gru 2018, o 14:15 --

Dziękuje wszystkim za wsparcie ale rozwiązałem już problem
Jeżeli zrobimy taki przykład to wystąpi błąd

Kod: Zaznacz cały

int *array ;
int *array_Home ;

array = new int[arra_size_A];

array_Home = array ;

*array = &array_Home -> to się nie zapisuje , jest błąd ;

======
Istnieje jednak możliwość zamiany zmiennej adresowej na typ int

Kod: Zaznacz cały

*array=*(int*)(void*)&array_Home;

To działa poprawnie

[leg14]

*array = &array_Home -> to się nie zapisuje , jest błąd ;

Wiesz, ze *array jest rownowazne array[0] ?
Nie kompiluje sie bo intowi probujesz przypisac adres - oczywiscie ze to nie bedzie dzialac.

Jezeli chcesz miec tabvlice adresow to musisz uzyc new int *[size] , czy jakos tak.

Pytanie po co alokujesz dynamicznie pamiec, jesli tego nie potrzebujesz?

Czemu uzywasz tablic zamiast kontenerow z bibliotek istandardowej?

[diskbit]

Oto Działający poprawiony kod ,
Proszę o uwagi i z góry dziękuje

Kod: Zaznacz cały

  int arra_size_A = 5 ;
    int arra_size_B = 7 ;

    int **ptr ;
    int **ptr_Home ;
    int *ptr_Home2 ;

    long *array_postion ;
    long *array_postion_Home ;

    //- - - - - - - - - - - - - - - -
    array_postion  = new long[arra_size_A];
    array_postion_Home=array_postion;
    //- - - - - - - - - - - - - - - -
    ptr  = new int*[arra_size_A];
    ptr_Home=ptr;
    //- - - - - - - - - - - - - - - -

    std::cout<< " example 1 - position 01 ***************************************** ";
    std::cout<<std::endl;

    ptr=ptr_Home;
    array_postion=array_postion_Home;
    for(int A = 0; A < arra_size_A; A++)
    {
        long PosAdress =0;
        ptr[A] = new int[arra_size_B];

        ptr_Home2 = ptr[A] ;
        PosAdress= *(long*)(void*)&ptr_Home2;

        *array_postion=PosAdress;

        for(int B = 0; B < arra_size_B; B++)
        {
            int a = rand()%1000;
            *ptr[A]=a;
            std::cout<< " [ "<< A <<","<< B <<  "=" << *ptr[A] << " Adres = " << ptr[A]<< "  Adres Start B =" << *array_postion <<" PTR Home 2 = " << ptr_Home2 << "  ] " ;
            ptr[A]++;
        }
        std::cout<<std::endl;
        array_postion++;
    }
    //==========================================================

    std::cout<< " example 1 -  positon 02 ***************************************** ";
    std::cout<<std::endl;

    ptr=ptr_Home;
    array_postion=array_postion_Home;
    for(int A = 0; A < arra_size_A; A++)
    {
        long PosAdress =*array_postion;
        ptr_Home2 = reinterpret_cast<int*>(PosAdress);
        ptr[A]=ptr_Home2;

        for(int B = 0; B < arra_size_B; B++)
        {
            std::cout<< " [ "<< A <<","<< B <<  "=" << *ptr[A] << " Adres = " << ptr[A]<< "  Adres Start B =" << ptr_Home2 <<" ] " ;
            ptr[A]++;
        }
        std::cout<<std::endl;
        array_postion++;
    }
    //==========================================================

    array_postion=array_postion_Home;
    delete[] array_postion ;

    ptr=ptr_Home;
    delete[] ptr ;

-- 16 gru 2018, o 18:10 --

Dlatego zastosowałem tą logikę obsługi macierzy ponieważ chodzi o czas działania
vector-owanie z tego co wiem jest czasochłonne .
W tygodniu napisze to również w tej technologi .
Sprawdzę co działa szybciej za pomocą

Kod: Zaznacz cały

clock_t starttime, stoptime;
double timevalue;

starttime = clock(); 
 ....Kod
stoptime = clock();

timevalue = (double)(stoptime - starttime) / CLOCKS_PER_SEC;

Zobaczymy która technologia jest szybsza . na tym mi właśnie zależy . to
jest jedyny powód iż sięgam do wskaźników

[leg14]

vector-owanie z tego co wiem jest czasochłonne .
W tygodniu napisze to również w tej technologi .
Sprawdzę co działa szybciej za pomocą

clock_t starttime, stoptime;
double timevalue;

starttime = clock();
....Kod
stoptime = clock();

timevalue = (double)(stoptime - starttime) / CLOCKS_PER_SEC;

Zobaczymy która technologia jest szybsza . na tym mi właśnie zależy . to
jest jedyny powód iż sięgam do wskaźników

Trudno mi się do tego ustosunkować, bo nadal nie wiem co ma robić program.
Dodam tylko, że jak już popadamy w taką paranoję, że używamy tablicy zamiast np. std::vector w celu optymalizacji (ja nie tam nie wiem czy jest jakaś zauważalna różnica, chyba nie...) to nie orzumiem dlaczego alokujesz dynamicznie pamięć skoro jest to wolniejsza opcja, a nic Ci nie daje - wielkość tablicy jest znana już w czasie kompilacji.