3. C++ und Arrays

C++ und Arrays

  • U

    mHochbach schrieb:

    Fragt mich nicht, warum das mit einem Pointer nicht geht, habe mich auch gewundert, aber naja...

    frag' ich dich aber. normalerweise kann man fast überall wo ein array erwartet wird auch pointer nehmen.
    ansonsten: nimm C99, da gibt es variable-length arrays. die werden tatsächlich so angelegt, wie du es haben willst...

    0
  • C
    Mod

    mHochbach schrieb:

    Fragt mich nicht, warum das mit einem Pointer nicht geht, habe mich auch gewundert, aber naja...

    Dann frage ich, wie eine typische Funktionsdeklaration mit so einem Parameter aussieht.

    0
  • M

    Danke für die Antworten.

    Nun, aufrufen kann ich die Funktion, aber es kommt etwas falsches bei raus...

    sie sieht so aus

    Die Funktionsdeklaration im Header...
size_t funk(void const *src, size_t srcSize, char *dest, size_t destLen);

Mein Code (Ausschnitt...)
1) int src[5];
2) int *src=(int*)malloc(5*sizeof(int));

size_t size = funk(&(src[0]), sizeof(src), param1, param2);

    mit 1) funktioniert es, mit 2) nicht.
    2) funktioniert noch nicht einmal, wenn ich einen festen Wert, wie oben die 5, eingebe.
    Die 5 in 2) soll dann natürlich dann die Variable sein, die zur Kompelierzeit noch nicht definiert ist...

    0
  • ?

    Du weißt schon, dass sizeof(int*) immer 4/8 ist?
    Du musst bei dem 2. parameter die größe, die du als speicher angefordert hast reinschreiben(entspricht: 5*sizeof(int)).

    0

  • Du kannst in C++ meist alloca verwenden um die nicht vorhandenen C99-style variable-length-arrays zu ersetzen:

    void f(int* p, unsigned length)
{
    int* p2 = static_cast<int*>(alloca(sizeof(int) * length));
    // p2 verwenden
    // ...

} // <- hier "verschwindet" der von alloca angeforderte Speicher automatisch

    Natürlich solltest du alloca nicht mit "Klassentypen" verwenden, zumindest mit nichts was einen Destruktor hat, denn dieser wird nicht aufgerufen.
    Das tolle an alloca ist nicht nur dass der Speicher bei verlassen der Funktion automatisch freigegeben wird, sondern auch dass alloca verdammt schnell ist.

    Intern passiert im übrigen genau dasselbe wie in C99 mit variable-length-arrays, d.h. der Speicher wird vom Stack genommen. Das bedeutet allerdings auch dass man nicht zuviel anfordern sollte, der Stack ist ja üblicherweise nicht sehr gross.

    0
  • *

    was spricht gegen new?

    template<typename T>
bool allocate(T** data, const std::size_t size)
{
    *data = new T[size];
    return (*data);
}
    0

  • Dass new um Faktor 1000 oder so (eher mehr) langsamer ist?
    Mann mann mann...

    BTW: dann nehm' ich aber gleich std::vector bevor ich new verwende...

    0
  • D

    Dennis hat zwar die Lösung schon auf den Punkt gebracht, aber ich werde es nochmal etwas ausführlicher machen.
    sizeof(x) ist ein Operator, der zur Kompilezeit bestimmt, welche Größe ein Ausdruck hat.
    Bei Arrays gibt er die Größe des Arrays in Byte zurück, da die Größe der Arrays schon zur Kompilezeit feststeht.
    Dynamisch allozierte Arrays werden in C++ durch einen Zeiger auf das erste Element dargestellt. sizeof() sieht nur diesen Zeiger und bestimmt somit seine Größe in Bytes (auf 32bit Systemen 4 Byte).
    Also hier nochmal anschaulich:

    int  source1[5];
int* source2 = new int[5];
sizeof(source1) // == 5*4 = 20 Byte;
sizeof(source2) // == 1*4 =  4 Byte;
// Jedenfalls auf meinem System

    Deshalb sollte man bei dynamisch angelegten Arrays die Größe mitspeichern.

    Gruß
    Don06

    0
  • M

    Vielen Dank für die schnellen Antworten.

    @Dennis123: Ich werde das morgen gleich mal testen. Hört sich aber logisch an. Werde morgen berichten, ob es funktioniert hat oder nicht.

    Auch an alle anderen ein herzliches Dankeschön.

    Viel Grüße Manfred

    0
  • M

    Danke Don06 für die ausführliche Beschreibung, werde ich in Zukunft beherzigen. Hat wunderbar funktioniert.

    Vielen Dank an alle, die hier geantwortet haben.

    Gruß Manfred

    0
Anmelden zum Antworten