3. Array = 0 setzen

Array = 0 setzen

  • M

    Hallo,

    um ein Array = 0 zu setzen, kann man es ja einzeln durchlaufen, also z.B. so:

    int array[100];

for (int i=0;i<100;i++)
    array[i] = 0;

    Nun kostet dies bei größeren Arrays viel Zeit, zumal wenn dies z.B. in einer rekursiven Funktion geschieht.
    Gibt es einen schnelleren Weg ein Array = 0 zu setzten? Muss dass Array dann eine bestimmte Größe haben?

    Würde mich freuen, wenn ihr mir weiterhelfen könntet.

    MfG
    modus

    0
  • S

    std::memset bzw. std::fill(_n) erledigen das für dich. Aber es dauert halt seine Zeit bei großen Arrays... Ich würde mir lieber überlegen, ob du nicht das 0-setzen sparen kannst...

    0
  • E

    Warum nicht so:

    int array[100]={0};

    Ist meiner Meinung nach am schnellsten und einfachsten.
    Gruß
    E-the-Real

    0
  • M

    Und dazu noch der einzige, auser mit schleife.

    0
  • M

    ... wenn ich das Array nur einmal global deklariere und es dann in jedem Aufruf
    meiner Funktion = 0 setzen möchte.

    Zum Beispiel:

    int array[100];

int blabla()
{
for (int i=0;i<100;i++)
   array[i] = 0;

return vielleicht_genau_das;
}

int rekursive_funktion()
{
int wert = blabla();

if (wert == genau_das) return wert;

return rekursive_funktion();
}

    In meinem Fall wird das Array, anders als in meinem Beispiel, nicht nur in der einen Funktion gebraucht, sondern noch an diversen anderen Stellen, deswegen muß es global deklariert werden.

    Gibt es hier auch eine schnelle Lösung?

    Vielen Dank für eure Hilfe!

    MfG
    modus

    0
  • C

    Du solltest dir überlegen, ob das sinnvoll ist. Erstmal sind globale Variablen selten notwendig. Weiterhin ist das doch, wenn du sie sowieso immer wieder auf Null setzt, doppelt unsinnig. Vielleicht solltest du mal erklären, was du genau vorhast. Ich bin davon überzeugt, dass sich eine andere Lösung finden lässt.

    0
  • F

    Wenn du einen schlauen Compiler hast kannst du auch ein sogenanntes 'loop unrolling' machen.
    Dann werden die Anweisungen in der Schleife 'gleichzeitig' erledigt.
    Also etwa so :

    for ( int i = 0; i < ARRAYGROESSE; i++ )
{
  array[i]   = 0;
  array[++i] = 0;
  array[++i] = 0;
  array[++i] = 0;
}

    So bist du 4x schneller als bei einer normalen loop!
    Kommt dann nnur noch auf die array Größe an, ob diese Methode schneller als memset ist.
    Kommt natürlich auf deinen Compiler an ob er das hinkriegt dieses auch gleichzeitig ausführen zu lassen. Schau mal in die Compilereinstellungen, ob das automatisch passiert oder du irgendwelche Schalter setzen kannst.

    0
  • J

    flouser schrieb:

    for ( int i = 0; i < ARRAYGROESSE; i++ )
{
  array[i]   = 0;
  array[++i] = 0;
  array[++i] = 0;
  array[++i] = 0;
}

    🙄

    0
  • A

    Also wenn diese Methode nicht ordentlich über die Array-Grenzen hinwegschießt 😃

    0
  • G

    memset dürfte immer schneller als irgendein C++ Code sein.

    Du musst nur aufpassen, dass die Arrayelemente nicht Objekte einer Klasse mit virtuellen Funktionen sind, sonst killst du die vtable.

    0
  • S
     

    int * array;

// Array allokieren
array = new int[100];
// Array löschen
delete [] array;
// Array allokieren
array = new int[100]; // natürlich ist es leer

    MfG

    Edit: Fehlt nur noch das Nullsetzen. *g*

    0
  • A

    Wozu ist dein Code jetzt gut??

    0
  • J

    Saiyaman schrieb:

    int * array;

// Array allokieren
array = new int[100];
// Array löschen
delete [] array;
// Array allokieren
array = new int[100]; // natürlich ist es leer

    MfG

    Edit: Fehlt nur noch das Nullsetzen. *g*

    Definiere leer.

    0
  • F

    Also wenn diese Methode nicht ordentlich über die Array-Grenzen hinwegschießt

    ...das ist wohl war! Also : ARRAYGROESSE/4

    memset dürfte immer schneller als irgendein C++ Code sein

    Eigentlich sollte man das annehmen. Das hängt aber von verschiedenen Dingen ab:
    - Groesse des arrays
    - was vorher im cache bearbeitet wurde
    - ob man einen guten/neueren Compiler benutzt

    Letztendlich wird aus jedem C++ Code auch nur Maschinencode, ebenso wie memset!

    Muesste man mal ausmessen, wie schnell sich welche Funktion für grosse arrays verhält.

    0
  • S

    ein gutes std::fill(_n) ruft intern std::memset auf, oder verwendet den selben algorithmus (natürlich nur für builtins)

    eine Schleife kann nicht schneller sein als memset - denn wenn das der Fall ist, würde ich sofort den Compiler wechseln. Schließlich sollte memset perfekt auf die verwendete Plattform optimiert sein.

    Aber warum macht ihr nicht einfach benchmarks?

    0
  • F

    Sollte man bei Zeiten durchaus mal tun!
    Bis dahin -> www.google.de - memset loop benchmark

    0
  • S

    Wie wär's mit einem 2. Array gleicher Größe. Das setzt man dann einmal Null. Bei Bedarf das 2. Array dem 1. Array zuweisen.

    MfG

    0
  • A

    Das wäre sogar (ein bisschen) langsamer als die for-loop Methode oder die memset-Funktion.

    0
  • J

    flouser schrieb:

    ...das ist wohl war! Also : ARRAYGROESSE/4

    Was wenn ARRAYGROESSE nicht durch 4 teilbar? Ausserdem wanderst du in der Schleife trotzdem nur um 1 Element weiter.

    0
  • ?

    Diese seltsame forschleife ist sowieso absoluter blödsinn!
    ob ich jetzt:

    mov cx, 100 ; arraysize
zero_array:
  mov byte [es:di], 0
  inc di
loop zero_array

    oder:

    mov cx, 25 ; arraysize/4
zero_array:
  mov byte [es:di], 0
  inc di
  mov byte [es:di], 0
  inc di
  mov byte [es:di], 0
  inc di
  mov byte [es:di], 0
  inc di
loop zero_array

    schreibe, ändert nichts an der geschwindigkeit!

    0
  • S

    DennisB schrieb:

    schreibe, ändert nichts an der geschwindigkeit!

    Natürlich tut es das.
    1. werden nur ein viertel der vergleiche durchgeführt und
    2. werden nur ein viertel der jumps durchgeführt.

    Siehe einfach Duffs Device
    Allerdings sollten gute Compile Loopunrolling beherrschen.

    0
Anmelden zum Antworten