1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

Dynamisches Array in Main mit -> Operator aufrufen - ****?

Dieses Thema im Forum "C/C++" wurde erstellt von Termos, 2. Mai 2012.

  1. Termos

    Termos Mitglied

    Im folgenden Programm habe ich versucht ein dynamisches Array zu erstellen ...

    Der aufruf der Klasse mit dem . Operator ist kein Problem, doch was muss ich ändern um es als Zeiger benutzen zu können ergo einen aufruf via
    Code (Text):
    1. d->set(0,ax,0,ay);

    Code (Text):
    1. #include "stdafx.h"
    2. #include <iostream>
    3. #include <cstring>
    4.  
    5. using namespace std;
    6.  
    7.  
    8. class zweidim
    9. {
    10.     private:
    11.         double **d;
    12.         size_t ax, ay;
    13.     public:
    14.         zweidim(int Zeilen=1, int Spalten=1)
    15.         {
    16.             ax = Zeilen;
    17.             ay = Spalten;
    18.            
    19.             if(ax>0&&ay>0)
    20.             {
    21.                 d = new double*[ax];
    22.                 for(size_t co=0; co<ax; co++)
    23.                 {
    24.                         d[co] = new double[ay];
    25.                 }
    26.  
    27.                 for(size_t i=0;i<ax;i++)
    28.                 {
    29.                     for(size_t n=0;n<ay;n++)
    30.                     {
    31.                         d[i][n]=0.0;                   
    32.                     }
    33.                 }
    34.             }
    35.             else
    36.             {
    37.                     cout<<"Falsche Eingabe "<<ax<<","<<ay<<"\n";
    38.                     d = NULL;
    39.             }
    40.         }
    41.  
    42.        double *& operator[] (size_t ax)  
    43.         {
    44.             return d[ax];
    45.         }
    46.  
    47.  
    48.  
    49.  
    50.  
    51.        /* ~zweidim()
    52.         {
    53.             int i;
    54.             for (i = 0; i < ax; i++)
    55.                     delete [] d[i];
    56.             delete [] d;
    57.         }*/
    58.  
    59.         ~zweidim() {
    60.             if(d != NULL) {
    61.                     for(size_t i=0; i < ax; i++)
    62.                         if(d[i] != NULL) {
    63.                             delete d[i];
    64.                             d[i] = NULL;
    65.                                 }
    66.                         delete [] d;
    67.                 d = NULL;
    68.                         }
    69.         }
    70.  
    71.         double summe(size_t ax0=0, size_t ax1=0,size_t ay0=0,size_t ay1=0)
    72.         {
    73.             double summe=0;
    74.             size_t temp;
    75.             //Testumgebung für alle Funktionen -> könnten auch als Funktion definiert werden ...
    76.             //test ob ax/y0 > ax/y1
    77.             if(ax0>ax1)
    78.             {
    79.                 temp=ax0;
    80.                 ax0=ax1;
    81.                 ax1=temp;
    82.             }
    83.  
    84.             if(ay0>ay1)
    85.             {
    86.                 temp=ay0;
    87.                 ay0=ay1;
    88.                 ay1=temp;
    89.             }
    90.             //test ende
    91.  
    92.             //Testen ob ay1|ax1 > this->ax/ay
    93.             if(ax1>=this->ax)
    94.             {
    95.                 ax1=(this->ax)-1;   //Klammern dienen nur der optik
    96.             }
    97.             if(ay1>=this->ay)
    98.             {
    99.                 ay1=(this->ay)-1;
    100.             }
    101.             //Testumgebung ende
    102.  
    103.                        
    104.             for(size_t i=ax0;i<=ax1;i++)
    105.                 {
    106.                     for(size_t n=ay0;n<=ay1;n++)
    107.                     {
    108.                         summe=summe+d[i][n];
    109.                     }
    110.                 }
    111.            
    112.             return summe;
    113.         }
    114.  
    115.                
    116.        
    117.  
    118.        
    119.         //Rückgabe von ax
    120.         size_t get_ax()
    121.         {
    122.             return this->ax;                //Rückgabe der Member variable
    123.         }
    124.         //Rückgabe von ay
    125.         size_t get_ay()                
    126.         {
    127.             return this->ay;                //Rückgabe der Member variable
    128.         }
    129.         //Wert an Position x,y setzen
    130.         void set(size_t ax=0, size_t ay=0, double wert=0.0)
    131.         {
    132.             if(d!=NULL && ax<this->ax && ay<this->ay)           //Prüfuen ob d existent / vergleich ob ax < als Member ax (ay)
    133.             {
    134.                 d[ax][ay]=wert;
    135.             }
    136.             else
    137.             {
    138.                 cout<<"Wert konnte nicht gesetzte werden, objekt nicht existent oder Position oberhalb des Arrays\n";
    139.             }
    140.  
    141.         }
    142.  
    143.         //Wert holen // Anzeigen
    144.         double get(size_t ax=0, size_t ay=0)
    145.         {
    146.             if(ax>this->ax || ay>this->ay)
    147.             {
    148.                 cout<<"Unzulässige Werte x y \n";
    149.                 return 0;
    150.             }else
    151.             {
    152.                
    153.             return  d[ax][ay];
    154.             }
    155.         }
    156.  
    157.         //Anzeigen Aller Elemente
    158.         void show(size_t ax0=0, size_t ax1=0, size_t ay0=0, size_t ay1=0)
    159.         {
    160.             //Testumgebung für alle Funktionen -> könnten auch als Funktion definiert werden ...
    161.             //test ob ax/y0 > ax/y1
    162.             int temp;
    163.             if(ax0>ax1)
    164.             {
    165.                 temp=ax0;
    166.                 ax0=ax1;
    167.                 ax1=temp;
    168.             }
    169.  
    170.             if(ay0>ay1)
    171.             {
    172.                 temp=ay0;
    173.                 ay0=ay1;
    174.                 ay1=temp;
    175.             }
    176.             //test ende
    177.  
    178.             //Testen ob ay1|ax1 > this->ax/ay
    179.             if(ax1>=this->ax)
    180.             {
    181.                 ax1=(this->ax)-1;   //Klammern dienen nur der optik
    182.             }
    183.             if(ay1>=this->ay)
    184.             {
    185.                 ay1=(this->ay)-1;
    186.             }
    187.             //Testumgebung ende
    188.            
    189.             //Ausgabe Schleife
    190.             for(size_t i=ax0;i<=ax1;i++)
    191.                 {
    192.                     for(size_t n=ay0;n<=ay1;n++)
    193.                     {
    194.                         cout<<d[i][n]<<"\t";
    195.                     }
    196.                     cout<<"\n";
    197.                 }
    198.         }//Ende Show
    199.  
    200.         void ein(size_t ax0=0, size_t ax1=0, size_t ay0=0, size_t ay1=0)
    201.         {
    202.             int wert=0;
    203.            
    204.             //Testumgebung für alle Funktionen -> könnten auch als Funktion definiert werden ...
    205.             //test ob ax/y0 > ax/y1
    206.             int temp;
    207.             if(ax0>ax1)
    208.             {
    209.                 temp=ax0;
    210.                 ax0=ax1;
    211.                 ax1=temp;
    212.             }
    213.  
    214.             if(ay0>ay1)
    215.             {
    216.                 temp=ay0;
    217.                 ay0=ay1;
    218.                 ay1=temp;
    219.             }
    220.             //test ende
    221.  
    222.             //Testen ob ay1|ax1 > this->ax/ay
    223.             if(ax1>=this->ax)
    224.             {
    225.                 ax1=(this->ax)-1;   //Klammern dienen nur der optik
    226.             }
    227.             if(ay1>=this->ay)
    228.             {
    229.                 ay1=(this->ay)-1;
    230.             }
    231.             //Testumgebung ende
    232.  
    233.  
    234.                 for(size_t i = ax0;i <=ax1;i++)                 //-1 da die werte von ax0 mit 1 kommen [Index0 beachten]
    235.                     {
    236.                         for(size_t n = ay0;n<=ay1;n++)          //-1 da die werte von ax0 mit 1 kommen [Index0 beachten]
    237.                         {
    238.                             cout<<"Eingabe ["<<i<<"],["<<n<<"] = ";
    239.  
    240.                             do {
    241.                                 cin>>wert;
    242.                                 if(cin.eof()) break;
    243.                                 if(cin.fail() || (cin.peek() != '\n')){
    244.                                     cout<<"Falsch, erneut eingeben: ";
    245.                                     cin.clear(); cin.ignore(INT_MAX,'\n');
    246.                                     continue;
    247.                                 }
    248.                                     break;
    249.                             } while(true);
    250.                             d[i][n]=wert;
    251.                             cout<<"\n";
    252.                         }
    253.                         cout<<"\n";
    254.                     }
    255.         }
    256. };
    257.  
    258.  
    259. int main()
    260. {
    261.     int ax,ay;
    262.     cout<<"Zeilen Anzahl: ";
    263.     cin>>ax;
    264.     cout<<"Spalten Anzahl: ";
    265.     cin>>ay;
    266.     zweidim d(ax,ay);
    267.     d.set(ax-1,ay-1,100);
    268.     cout<<"Element ["<<ax<<"]["<<ay<<"] = "<<d.get(ax-1,ay-1)<<"\n";
    269.     d.show(0,ax,0,100);
    270.     d.ein(0,ax,0,ay);
    271.     d.show(0,ax,0,ay);
    272.     cout<<"gesamtsumme = "<<d.summe(1,ax,1,ay)<<"\n";
    273.  
    274.  
    275.     system("PAUSE");
    276.     return 0;
    277. }
     
  2. deepthroat

    deepthroat Premium-User

    Um es als Zeiger benutzen zu können muss es ein Zeiger sein. :eek:

    Was ist denn der Sinn deiner Frage?

    Code (C++):
    1. zweidim* pd = &d;
    2.  
    3. pd->set(...);
    Gruß
     
  3. sheel

    sheel I love Asm Administrator

    Hi

    Code (C++):
    1. zweidim d(ax,ay);
    änderst du zu
    Code (C++):
    1. zweidim *d = new zweidim(ax,ay);
    Und am Schluss (vor return) kommt noch ein
    Code (C++):
    1. delete d;
    rein.

    Dass du die . in-> ändern musst (oder (*d). ) weißt du ja.

    Gruß

    Ergänzung: deepthroats Variante verwendet eine zweite Variable als Pointer auf die Normale.
    new/delete entfallen deswegen, weil die eigentliche Variable ja die Normale ist
    und das dort schon vom Compiler übernommen wird.
    Der Pointer ist dabei nur eine Art Alias.
     
    Zuletzt bearbeitet: 2. Mai 2012
  4. Termos

    Termos Mitglied

    Super vielen dank ;)

    Code (Text):
    1. zweidim *d = new zweidim(ax,ay);
     
    Zuletzt bearbeitet: 2. Mai 2012
  5. deepthroat

    deepthroat Premium-User

    Sollte
    Code (C++):
    1. zweidim *d = new zweidim(ax, ay);
    heißen.

    Gruß
     
  6. Termos

    Termos Mitglied

    Jo habe es gemerkt, vielen dank ;) Wieder mal den tag gerettet******!
     

Diese Seite empfehlen