Zwei Argumente für calloc

Question 1

Warum tut calloc Nehmen Sie zwei Argumente anstelle von einem wie malloc?

Insbesondere, da zwischen den folgenden Ausdrücken kein Unterschied besteht (oder besteht?):

calloc (a, b);
calloc (b, a);
calloc (a * b, 1);
calloc (1, a * b);

Warum nicht einfach die Gesamtzahl der zuzuweisenden Bytes akzeptieren? Was ist der Grundgedanke hinter dieser Schnittstelle? Und warum gilt das nicht für malloc?

Question 2

Ich habe zwei gehört [mutually exclusive] Erklärungen dafür, warum es zwei Argumente hat:

calloc übernimmt die Verantwortung für die Prüfung auf Überlauf bei der Multiplikation. Wenn die Gesamtgröße des angeforderten Blocks zu groß ist (z. B. overflows size_t), calloc gibt einen Nullzeiger zurück, um einen Fehler anzuzeigen. Mit malloc Sie müssen selbst auf Überlauf achten, was viele Menschen einfach vergessen. (Obwohl die Geschichte der Standardbibliothek Beispiele dafür kennt calloc Implementierungen, die den Überlauf ignorierten und daher nicht korrekt funktionierten).
calloc ermöglicht es tatsächlich, größere Speicherblöcke als den Typbereich zuzuweisen size_tdh calloc möglicherweise in der Lage sein, die richtige nicht überlaufende große Multiplikation seiner Argumente durchzuführen und den Block der resultierenden Größe zuzuweisen. Aus diesem Grund seit calloc verwendet zwei Argumente vom Typ size_tes kann größere Blöcke zuweisen als malloc jemals in der Lage sein werden (seit malloc akzeptiert nur ein Argument vom Typ size_t).

Ich habe immer geglaubt, dass die erste Erklärung die richtige ist. Nachdem ich jedoch einige Beiträge hier auf SO gelesen habe, habe ich meine Zweifel.

Question 3

Ich glaube, dass malloc garantiert einen Speicherbereich zurückgibt, der gemäß der gröbsten Anforderung ausgerichtet ist, die mit der durch das zweite Argument angegebenen Größe kompatibel wäre. Wenn das System beispielsweise eine Ausrichtung von 2- und 4-Byte-Ganzzahlen erfordert und das zweite Argument 10 ist, muss der zurückgegebene Zeiger an einer Zwei-Byte-Grenze ausgerichtet werden; Wenn das zweite Argument 12 wäre, würde der Zeiger an einer Vier-Byte-Grenze ausgerichtet werden. Ich vermute, dass viele Systeme in der Praxis alle zurückgegebenen Zeiger an der größten möglicherweise erforderlichen Grenze ausrichten, unabhängig von der Größe, aber ich glaube nicht, dass dies erforderlich ist, außer für calloc.

Question 4

Der einzige bemerkenswerte Unterschied ist der calloc ist erforderlich, um den zugewiesenen Speicherplatz auf Nullen zu initialisieren, obwohl es keine solche Garantie gibt malloc. Ansonsten denke ich, dass es nur aus historischen Gründen zwei verschiedene Funktionen gibt.

Question 5

Alles sind nur Bytes ist eine relativ neue (dh c/Unix-Ära) Erfindung – auf vielen anderen Architekturen waren die Dinge Datensätze mit fester Größe.

Question 6

calloc(x,y) ist ein Äquivalent zu malloc(x*y)

Aber calloc tut zusätzlich (Werte auf 0 setzen mit) memset(block, 0, x*y)

Diese Funktion ist nur für den hübschen Weg vorbei Größe des Elements und Anzahl der Elementewenn Sie in malloc diese Werte multiplizieren müssen, um die erforderliche Anzahl von Bytes zu erhalten, prüft diese Funktion auch den Ganzzahlüberlauf bei der Multiplikation.

Wenn Sie beispielsweise Speicher für 12 Ganzzahlen zuweisen möchten und etwas mit diesen Ganzzahlen tun möchten und Sie ihre Werte auf 0 gesetzt haben müssen, verwenden Sie calloc(12, sizeof(int))

Aber wenn Sie einen Speicherblock (256 Bytes) zuweisen möchten, um in Zukunft eine Zeichenfolge zu kopieren memset Ist eine für Sie nicht nutzbar, dann ist eine bessere Nutzung sinnvoll malloc(sizeof(char) * 256) oder zum Beispiel malloc(sizeof(wchar_t) * 256)

void *
calloc (size_t nmemb, size_t lsize)
{
  void *ptr;
  struct __meminfo *info;
  size_t size = lsize * nmemb;

  /* if size overflow occurs, then set errno to ENOMEM and return NULL */
  if (nmemb && lsize != (size / nmemb))
    {
      set_errno (ENOMEM);
      return NULL;
    }

  /* allocate memory */
  ptr = malloc (size);

  /* get pointer to info part of chunk */
  info = __mem2info (ptr);

  /* fill memory with zeros and set __MEM_CALLOC flag */
  memset (ptr, 0, info->size);
  info->flags |= __MEM_CALLOC;

  return ptr;                   /* happy end */
}