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 Grünschnabel

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

    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 Grünschnabel

    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 Grünschnabel

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

Diese Seite empfehlen