Array Elemente

K

Kleiner Wicht

Mitglied
Krieg noch ne Macke mit dem Scheiss C++ !

Damals noch in PHP alles no Problem, da hats Spass gemacht mit Array
zu arbeiten.

In C++ bekomm ich das einfach nicht richtig auf die Reihe und verliere echt die Lust.

Also was ich nicht auf die Reihe bekomme ist die Anzahl der Elemente dieses Arrays
zu erhalten:

Code: 
  int c = 300;
  
  int *t;
  t = new int[ c];
  
  for(int i=0; i<c;i++)
  t[i]=i;
  
  int u = sizeof(t)/sizeof(int);
  Application->MessageBox(IntToStr(u).c_str(), &quot;Elemente&quot;, MB_OK);

Die Messagebox spuckt einen Wert von 1 aus, ist natürlich falsch !
Wo ist das Problem ?
 
Kleiner Wicht hat gesagt.:
Krieg noch ne Macke mit dem Scheiss C++ !

Damals noch in PHP alles no Problem, da hats Spass gemacht mit Array
zu arbeiten.
Zum Vergrößern anklicken....
Ohne auf deinen Quellcode zu schauen, weiss ich sofort, dass das Problem nicht an der Sprache C++ und schon gar nicht am Compiler liegt! :rolleyes:
Junge Junge Junge, sowas kann ich leiden...

Vor allem ist das kein C++ sondern C!
Mit C++ benutzt man die STL mit vector, map etc. da gibt es dann auch richtige count-Funktionen für die Anzahl von Elementen.

:google: :suchen:

Info zu sizeof:
http://msdn.microsoft.com/library/d...us/vclang/html/_clang_the_sizeof_operator.asp
 
So So, ABER:

Anscheinend bist Du nicht in der Lage folgendes zu Begreifen:

1. Array - statisch
2. Array - dynamisch

1. Statisches Array
-----------------------------
Code: 
 int a_static[]={1,2,3,4,5};
 int anzahl=sizeof(a_static)/sizeof(int);
 
 cout<<anzahl<<endl;
 
 //die Anzahl der Elemente wird hier korrekt ausgegeben !


2.Dynamisches Array
-------------------------------
Code: 
 int e = 5;
 int *inhalt;
 inhalt = new int[e];
 
 for(int a=0; a<e ; a++)
 {
 	inhalt[a] = a;
 }
 
 int anzahl=sizeof(inhalt)/sizeof(int);
  cout<<anzahl<<endl;
 
 delete(inhalt);
 inhalt = NULL;


So bei dem ersten statischen Array wird die Anzahl der Elemente korrekt ausgegeben.
WESHALB und WIESO bei einem DYNAMISCHEN ARRAY die ANZAHL der ELEMENTE nicht ausgegeben werden kann, ich nicht wissen

@THOMAS KUSE
Ohne überheblich zu werden, weiß ich, das DUUUU es auch nicht weißt,
weshalb bei einem Dynamischen Array die Anzahl der Elemente so nicht
ausgegeben werden kann.
Niemand zwingt dich auf Quellcode anderer zu schauen


Ich hoffe das es wenigstens ein Mensch auf diesem Planeten gibt,
der weiß warum es nicht funktioniert.
Ein Beispiel wie es funktioniert wäre auch sehr schön, fals das überhaupt
möglich ist.

MfG
 
Hallo,

Wo ist das Problem ?
Zum Vergrößern anklicken....

1. Array - statisch
2. Array - dynamisch
Zum Vergrößern anklicken....

Genau da liegt dein Problem.
Wie soll der Compiler zur Übersetzungszeit die Groeße eines dynamischen
Arrays zur Kompilezeit ermitteln koennen (denn genau das macht der sizeof
operator). Wenn man mal nachdenkt ist das logisch gell?
Also du bekommst da die Größe des Pointers zurück. Du kannst den
sizeof Opertaotr nur auf Datenstrutkruen richtig anwenden wenn sie
statisch angelegt werden bzw wenn sie aufm Stack liegen. Diese Größen
koennen nämlich zur Kompilierzeit ermittelt werden (übrigens zählt
da auch die Groeße deines integer Zeigers dazu denn der wird auch auf
statisch(zur Übersetzungszeit) angelegt, das auf was er zeigt wird aber
dynamisch allokiert). Du hast mehrere Möglichkeiten:

1.) Du legst das Array aufm Stack an.
2.) Du deklarierst dir eine konstante Variable size die die Arraygröße angibt
3.) Du benutzt wie Thomas Kuse schon sagte die Container aus der stl.

@Thomas
Ohne auf deinen Quellcode zu schauen, weiss ich sofort, dass das Problem nicht an der Sprache C++ und schon gar nicht am Compiler liegt!
Zum Vergrößern anklicken....
Das hat der Threadersteller beides auch nie behauptet. Er ist bzw war
lediglich etwas frustriert da er den background von sizeof nicht kannte...

Vor allem ist das kein C++ sondern C!
Zum Vergrößern anklicken....

Wieso soll das kein C++ sein? In Java z.B. gibt es auch Möglichkeiten
dynamische Arrays anzulegen und diese zu
verwenden, deswegen proprammiert man aber immer noch in Java.
Und ich glaube kaum das
Code: 
for(int i=0; i<c;i++)
oder
Code: 
Application->MessageBox(IntToStr(u).c_str(), &quot;Elemente&quot;, MB_OK);
in C geht.
unge Junge Junge, sowas kann ich leiden...
Zum Vergrößern anklicken....
Immer easy bleiben :)
Mit C++ benutzt man die STL mit vector, map etc. da gibt es dann auch richtige count-Funktionen für die Anzahl von Elementen.
Zum Vergrößern anklicken....
Man kann sie benutzen aber wieso sollte man wenn es angebracht ist
nicht auch Arrays benutzen koennen? Die Zugriffszeiten sind viel schneller
(konstanter Aufwand) als die eines Vektors bzw einer Liste.
Natürlich ist eine Liste bzw ein Vektor sicherer und auch leichter
zu verwalten, aber wenn keine Notwendigkeit besteht eine
dynamisch anwachsende Datenstruktur zu verwenden, kann man
meiner Ansicht nach auch Arrays verwenden ohne sich von der
Programmiersprache abzuwenden :)
Aber prinzipiell gilt nat. wenn man eine Liste braucht und in C++ entwickelt
sollte man auf die stl zurückgreifen und bei der verwendung von strings
in C++ natürlich prinzipiell.

Gruß

RedWing
 
Zuletzt bearbeitet:
Okay, wusste nicht das sizeof beim Kompilieren ermittelt,
wie groß das Array mal später sein wird.

Selbst ein angeblich Dynamisches Array ist in gwisser Hinsicht statisch.
Ist ebend doch nich alles so Dynamisch wie ich immer dachte.

Aus den 3 Möglichkeiten, gefällt mir Möglichkeit 2, diese verwende ich schon ne
ganze Weile, dachte aber ich kann mir das spaaren, und ermittle mit sizeof die
größe des reservierten Speichers (Array), aber puuste Kuchen, nich.

Und auf den ganzen nicht Programmierer-Kram beim angeblichen Programmieren,
fahre ich sowieso nicht ab.

Okay Danke für die ausführliche Anleitung, damit kann ich ein Anfänger leben.

NICHT in C -> Application->MessageBox(IntToStr(u).c_str(), &quot;Elemente&quot;, MB_OK);

bis die Tage
 
Hallo,
vielleicht noch zur Info:

Man muss die Begriffe statisch und dynamisch etwas differenzierter
betrachten:
In Bezug auf Datenstrukturen bedeutet
statisch:
die Größe einer Datenstruktur ist statisch, d.h. sie kann nicht wachsen
oder schrumpfen
dynamisch:
die Größe einer Datenstruktur kann dynamisch
anwachsen bzw schrumpfen (darunter fällt ein vector oder eine list)

In Bezug auf Festlegungen bedeutet
statisch: alles was vor der Laufzeit festgelegt und allokalisiert werden
kann (darunter fällt dein Zeiger auf das Array)
dynamisch:
alles was während der Laufzeit ermittellt
werden und allokalisiert werden kann (darunter fällt dein Array selber)


Gruß

RedWing
 
Hi.

Ein Vector allgemein ist ein dynamisches Array. Speziell in C++ ist mit vector normalerweise ein std::vector aus der C++ Standard Template Library gemeint. Ein std::vector ist eine Template Klasse, also im Grunde ein "unfertiger" Typ der erst noch zur Kompilierzeit komplettiert wird.

Gruß
 
Hallo,

der Begriff Vektor bezeichnet allgemein ein Array. Egal ob dynamisch oder statisch...
Die Terminologie kommt daher, das ein Array der Größe n in C++/C einem Vektor aus dem R^n
aus der Mathematik entspricht...

Der stl vector ist in erster Linie ein dynamisch wachsendes Array. Um diesen vector
auf verschiedene Datentypen anzuwenden, verwendet man wie deepthroat schon
erwähnte den Templatemechanismus...

//edit: Hier findest du die API Doku zum stl vector:
http://www.sgi.com/tech/stl/table_of_contents.html

Gruß

RedWing
 
Zuletzt bearbeitet:
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück