Array reservieren (malloc)

[locus vivendi]

Hallo! Ich versuche ein mehrdimensionales Array zu reservieren mit einem Array auf Arrays. Ist das so ok?

Ich kann soweit auch keinen eindeutigen Fehler entdecken.

Aber die Präprozessormakros, die Typedefs und die seltsamen gewählten Stellen für Variablendeklarationen sind nicht schön:

- Streiche TRUE und FALSE und benutze true und false.
- Deklariere Variablen erst dort wo sie gebraucht werden.
- Benutze statt S4 entweder signed int wenn du einfach nur ein Integer brauchst, oder size_t wenn es um die Größe von Objekten geht oder z.B. int32_t wenn du wirklich Integer einer bestimmten Größe brauchst.
- Steiche U1 komplett und benutze einfach unsigned char.

- Beim Rückgeben des Zeigers aus deiner Anforderungsfunktion den Typ wegzuwerfen kommt mir auch seltsam vor.

Außerdem kannst du allein durch verwenden deiner Freigabefunktion den Code kürzer und wesentlich übersichtlicher machen. Ungefähr so:

#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

void free_array(signed** array, size_t n_rows)
{
  assert(array || n_rows == 0);
  
  for(size_t c = 0; c != n_rows; ++c)
  {
    free(array[c]);
  }
  free(array);
}

signed** allocate_array(size_t n_rows, size_t n_columns)
{
  assert(n_columns > 0);
  
  if(n_rows == 0) { return 0; }
  
  signed** array = static_cast<signed**>(calloc(n_rows, sizeof(signed*)));
  if(!array) {
    errno = ENOMEM;
    return 0;
  }
  
  for(size_t c = 0; c != n_rows; ++c)
  {
    array[c] = static_cast<signed*>(calloc(n_columns, sizeof(signed)));
    if(!array[c]) {
      free_array(array, c);
      errno = ENOMEM;
      return 0;
    }
  }
  
  return array;
}

int main()
{
  size_t const n_rows = 111;
  size_t const n_columns = 99;
   
  signed** p = allocate_array(n_rows, n_columns);
  if(!p) {
    fprintf(stderr, "Failed to allocate memory!\nThis program will terminate now.\n");
    return EXIT_FAILURE;
  }
  
  for(size_t c = 0; c != n_rows; ++c)
  {
    p[c][0] = 0;
    p[c][n_columns - 1] = 1;
  }
  
  free_array(p, n_rows);
}

Z.b. durch verwenden von new/delete statt malloc/free könnte man es noch ein bißchen kompakter mache, aber bin jetzt erstmal davon ausgegangen dass du wirklich malloc und free benutzen möchtest.

In meinem großen Programm kommt es zu komischen Fehlern, aber das Testprogramm scheint zu laufen?!

Wende Valgrind auch auf das große Programm an.

[anda_skoa]

Zdurch verwenden von new/delete statt malloc/free könnte man es noch ein bißchen kompakter mache, aber bin jetzt erstmal davon ausgegangen dass du wirklich malloc und free benutzen möchtest.

Du gehst von C++ aus, die Fragestellung klingt aber eher nach plain C.
Erklärt einige der Dinge, die du bemängelt hast

Ciao,
_

[locus vivendi]

Du gehst von C++ aus, die Fragestellung klingt aber eher nach plain C.

Stimmt...

Erklärt einige der Dinge, die du bemängelt hast

... aber nicht ganz. Alles was ich aufgezählt habe lässt sich sowohl in C als auch in C++ umsetzen. Teilweise hatte C die entsprechende Möglichkeit sogar vor C++, z.B. die Integer Typen mit spezifiziertem Umfang (int32_t und Konsorten). Viele von denen sind zwar genau genommen optional, aber wenn die Standardbibliothek sie nicht hat, werden die Chancen wohl nicht gut stehen sie selber definieren zu können, vorausgesetzt Compiler+Bibliothek sind einigermaßen aktuell.

[jay-t]

Danke mal für eure Antworten, werde das jetzt ändern.

Du gehst von C++ aus, die Fragestellung klingt aber eher nach plain C.

Ja, stimmt ist einfaches C.