Ich habe folgendes Programm das vereinfacht in etwa so aussieht:

class berta
{
 int feldeins[10];
 int feldzwei[20];

 void crc(int *);
 void haupt();
}

haupt()
{
 printf("%d",sizeof(feldeins));
 crc(feldeins);
}

crc(int *m)
{
printf("%d",sizeof(m));
}

Ich hab das problem das ich die unterfunktion crc für 2 verschiedene feldgrößen benötige und ich jeweils in der funktion wissen will wie gross das feld ist. Bloss liefert mit das printf im unterprogramm nicht die richtige Größe..

m müsste doch auch 4 Byte groß sein?

weis jemand rat?

Hallo Leute,

Ich habe folgende Unterfunktion die in etwa so aussieht:

class berta
{
 int feldeins[10];
 int feldzwei[20];

 void crc(int *);
 void haupt();
}

haupt()
{
 printf("%d",sizeof(feldeins));
 crc(feldeins);
}

crc(int *m)
{
printf("%d",sizeof(m));
}

Ich hab das problem das ich die unterfunktion crc für 2 verschiedene feldgrößen benötige und ich jeweils in der funktion wissen will wie gross das feld ist. Bloss liefert mit das printf im unterprogramm nicht die richtige Größe..

m müsste doch auch 4 Byte groß sein?

weis jemand rat?

troll

...

crc(int *m) {
   printf("%d",sizeof(m));
}

Welchen Typ hat m ? => int*
Welche Größe hat "int*" => immer denselben, egal, wo der Zeiger hinzeigt (Bei Deiner Plattform offensichtlich 4 "char-Einheiten").
=> Alles in Ordnung mit Deinem Compiler !
Alternative:

class berta
{
 int feldeins[10];
 int feldzwei[20];

 void crc(int *, size_t);
 void haupt();
}

haupt()
{
 printf("%d",sizeof(feldeins));
 crc(feldeins, sizeof(feldeins));
}

crc(int *m, size_t len)
{
printf("%d",len);
}

Ach ja: WENN crc() schon eine Memberfunktion von "berta" ist, ha sie doch sowieso Zugriff auf die Member feldeins und feldzwei .... warum noch separat übergeben ?

Gruß,

Simon2.

Ach ja: WENN crc() schon eine Memberfunktion von "berta" ist, ha sie doch sowieso Zugriff auf die Member feldeins und feldzwei .... warum noch separat übergeben ?

Weil ich alleine durch die Größe der Übergabeparameter entscheiden will was crc macht. Hab ja nur das problem mit sizeof()
Ich will einfach keine zusätzlichen ÜP einführen...

eben nicht!!!... crc liefert 1 und haupt liefert 4......(byte)....

Seltsam, bei mir nicht:

struct berta {
 int feldeins[10];
 int feldzwei[20];

 void crc(int *);
 void haupt();
};  

void berta::haupt() {
   printf("%d\n",sizeof(feldeins));
   crc(feldeins);
}  

void berta::crc(int *m) {
   printf("%d\n",sizeof(m));
}

int main () {
   berta b;
   b.haupt();

   return 0;
}

liefert wie erwartet:

40
4

(bei mir ist offensichtlich ein int 4 Byte groß und ein Pointer auch)

Ach ja: Was ist "ÜP" ?

Gruß,

Simon2.

Kann man das irgendwie verhindern bzw. einen zusätzlichen Übergabeparameter (ÜP) vermeiden?

Kann man das irgendwie verhindern bzw. einen zusätzlichen Übergabeparameter (ÜP) vermeiden?

Klar, indem man nicht ein C-Array verwendet sondern einen C++-Datentyp ('std::vector' oder 'std::tr1::array').

struct berta {
 vector<int> array
 array feldeins[10];
 array feldzwei[20];

 void crc(int *);
 void haupt();
};  

void berta::haupt() {
   printf("%d\n",sizeof(feldeins));
   crc(feldeins);
}  

void berta::crc(int *m) {
   printf("%d\n",sizeof(m));
}

int main () {
   berta b;
   b.haupt();

   return 0;
}

schau ma mal obs funktioniert...

...so wie ich das nun verstehe gibt nun das Unterprogramm crc nicht mehr Gesamtgröße von feldeins aus sondern nur die Größe eines Pointers oder?...

Japp ! Du erhältst auch denselben Wert, wenn Du sizeof() auf einen "MyBigObject*" machst.

traceman schrieb:

...
Kann man das irgendwie verhindern bzw. einen zusätzlichen Übergabeparameter (ÜP) vermeiden?

Mir fallen spontan 3 Möglichkeiten ein:
a) "verstecken 1" (elegant): Nimmst Du statt der int[] lieber std::vector<int>, dann merkt der sich das für Dich:

#include <iostream>
using std::cout;
#include <vector>

struct berta {
   vector<int> feldeins, feldzwei;
   berta() : feldeins(10),  feldzwei(20) {}

   void crc(vector<int>&);
   void haupt();
};  

void berta::haupt() {
   cout << feldeins.size()*sizeof(int) << "\n"; // falls Du nur die Anzahl der Elemente brauchst und nicht die Größe in Byte,
      // brauchst Du nur das "sizeof(int) wegzulassen.
   crc(feldeins);
}  

void berta::crc(vector<int>& m)
   cout << m.size()*sizeof(int) << "\n";
}

(habe mal ein wenig C raus und "++" reingenommen )

b) "verstecken 2" (hässlich): Hier hast Du keinen zusätzlichen, sondern einen anderen Übergabeparameter (...ähhh "ÜP" ):

struct berta {
 int feldeins[10];
 int feldzwei[20];

 void crc(size_t feldNummer);
 void haupt();
};  

void berta::haupt() {
   crc(1);
}  

void berta::crc(size_t feldNummer) {
   size_t feldGroesse;
   switch(feldNummer) {
   case 1: feldGroesse = sizeof(feldeins); break;
   case 2: feldGroesse = sizeof(feldzwei); break;
   default: throw runtime_error("gaaaanz unschön");
   }
   // ...
}

3.) "Typunterschied bei Referenzen ausnutzen": Das ist wohl ein wenig oversized

typedef int shortField[10];
typedef int longField[20];

struct berta {
 shortField feldeins;
 longField feldzwei;

 void crc(shortField&);
 void crc(longField&);
 void haupt();
};  

void berta::haupt() {
   printf("%d\n",sizeof(feldeins));
   crc(feldeins);
   crc(feldzwei);
}  

void berta::crc(shortField& m) {
   cout << "crc(shortField&): " << sizeof(m) << "\n";
}   
void berta::crc(longField& m) {
   cout << "crc(longField&): " << sizeof(m) << "\n";
}

Gibt auch noch ne "templatisierter Variante"...

Ich würde entweder den einen Parameter mehr spendieren oder eben mit vector arbeiten.

Gruß,

Simon2.

...

struct berta {
 vector<int> array
 array feldeins[10];
 array feldzwei[20];
...

schau ma mal obs funktioniert...

Bestimmt nicht (jedenfalls nicht so, wie Du's haben möchtest ).
Mal vom fehlenden ";" abgesehen:

vector<int> array // definiert keinen "Typ", sondern eine Variable namens "array"
=> 
 typedef vector<int> array;

 array feldeins[10]; // definiert feldeins als CArray von 10 vectoren !!
...

Naja, mein Beispiel oben zeigt Dir, wie's geht.

Ach ja: Benutze doch bitte nicht die "code"-, sondern die "cpp"-Tags, die machen uns das Lesen leichter.

Gruß,

Simon2.

many thx!!

aye!

Recht so !

Gruß,

Simon2.

aye!

Arrr!