Kann das mal bitte jaemand überprüfen ob man das so lassen kann?

Es geht nur darum sich das Leben zu vereinfachen was dynamische Speicherverwaltung in "C" angeht!
Das betrifft die häufige Verwendung ganz elementarer und häufig verwendeter
Datentypen als dynamischer Speicher!?!

fuer Kritik und Anregung schon Dank im voraus besten Dank!!

/*
     Autor: sclearscreen
     Thema: Vereinfachung Dynamischer Speicherverwaltung unter C
*/
#ifndef __DYNMEM__H
#define __DYNMEM__H
#include <stdlib.h>

////////////////////////////////////////////////////////////////////////////////
// Erzeugung und Freigabe einer einzelnen Zeichenkette die aus "char" besteht

char * getDynString(int);
char * getDynString(int anz)
{
     if(anz <= 0) return (char *) NULL;
     return ( (char *) malloc(anz + 1) );
}

void free_String(char *);
void free_String(char *string)
{
     if(string != NULL)
          free(string);
}
////////////////////////////////////////////////////////////////////////////////
// Erzeugung und Freigabe eines dynamisch erzeugten Feldes von "Integern"
int ** getDynIntegers(int);
int ** getDynIntegers(int anz)
{
     if(anz <= 0) return (int **) NULL;
     return ((int **) malloc( sizeof(int *) * anz));
}

void free_Integers(int**);
void free_Integers(int** integers)
{
     if(integers != NULL)
          free(integers);
}

////////////////////////////////////////////////////////////////////////////////
// Erzeugung und Freigabe eines dynamisch erzeugten Feldes vom Datentyp "short"
short ** getDynShorts(int);
short ** getDynShorts(int anz)
{
     if(anz <= 0) return (short **) NULL;
     return ((short **) malloc( sizeof(short *) * anz));
}

void free_Shorts(int**);
void free_Shorts(int** shorts)
{
     if(shorts != NULL)
          free(shorts);
}

////////////////////////////////////////////////////////////////////////////////
// Erzeugung und Freigabe eines dynamisch erzeugten Feldes vom Datentyp "float"
float ** getDynFloats(int);
float ** getDynFloats(int anz)
{
     if(anz <= 0) return (float **) NULL;
     return ((float **) malloc( sizeof(float *) * anz));
}

void free_Floats(float**);
void free_Floats(float** floats)
{
     if(floats != NULL)
          free(floats);
}

////////////////////////////////////////////////////////////////////////////////
// Erzeugung und Freigabe eines dynamisch erzeugten Feldes vom Datentyp "double"
double ** getDynDoubles(int);
double ** getDynDoubles(int anz)
{
     if(anz <= 0) return (double **) NULL;
     return ((double **) malloc( sizeof(double *) * anz));
}

void free_Doubles(double**);
void free_Doubles(double** doubles)
{
     if(doubles != NULL)
          free(doubles);
}

////////////////////////////////////////////////////////////////////////////////
// Erzeugung und Freigabe eines dynamisch erzeugten Feldes vom Datentyp
// "long double"
long double ** getDynLongDoubles(int);
long double ** getDynLongDoubles(int anz)
{
     if(anz <= 0) return (long double **) NULL;
     return ((long double **) malloc( sizeof(long double *) * anz));
}

void free_LongDoubles(long double**);
void free_LongDoubles(long double** longdoubles)
{
     if(longdoubles != NULL)
          free(longdoubles);
}
#endif

fehlt noch was oder wuerdet ihr das anders machen !???!
mfg

rüdiger

nebenbei, dass ich deinen Code überflüssig finde, noch folgendes:

a) für größen Angaben nimmt man size_t und nicht int, dann sparst du dir auch die überprüfung auf <=0

b) free(NULL); ist absolut legal und ein vorheriges prüfen auf != NULL ist überflüssig

c) Bezeichner mit doppeltem Unterstrich sind nicht erlaubt (siehe deine Include-Wächter)

Ich arbeite privat mehr in C++.
Ab und an kommt man in verlegenheit das man doch mal direkt in "C"
proggt!
Und dort sind mir die Varianten mit "malloc" je nach Verwendung nicht so
ganz geläufig was Uebergabeparameter betrifft da finde ich es einfacher
wenn man ne Funktion hat wo man nur die Anzahl uebergibt!