символ x [256] по сравнению с символом* = malloc (256*sizeof (символ));

Здесь существует третья возможность, которая является, что массив может быть объявлен внешний к функции, но статически, например,

// file foo.c
char name[256];

int foo() {
    // do something here.
}

Я был скорее удивлен в ответах на другой вопрос на том, Так, чтобы кто-то чувствовал, что это было несоответствующим в C; вот, это даже не упоминается, и я немного смущен и удивлен (как, "что они преподают детям в школе в эти дни?") об этом.

При использовании этого определения память выделяется статически, ни на "куче", ни на стеке, но в пространстве данных в изображении. Таким образом ни не должен управляться как с malloc/free, и при этом Вы не должны волноваться об адресе, снова используемом, как Вы были бы с автоматическим определением.

Полезно вспомнить целое, "объявленное" по сравнению с "определенной" вещью здесь. Вот пример

/* example.c */

char buf1[256] ;           /* declared extern, defined in data space */
static char buf2[256] ;    /* declared static, defined in data space */
char * buf3 ;              /* declared extern, defined one ptr in data space */
int example(int c) {       /* c declared here, defined on stack */
    char buf4[256] ;       /* declared here, defined on stack   */
    char * buf5 = malloc(256)]   /* pointer declared here, defined on stack */
                           /* and buf4 is address of 256 bytes alloc'd on heap */
    buf3 = malloc(256);    /* now buf3 contains address of 256 more bytes on heap */

    return 0;              /* stack unwound; buf4 and buf5 lost.      */
                           /* NOTICE buf4 memory on heap still allocated */
                           /* so this leaks 256 bytes of memory */
}

Теперь в совершенно другом файле

/* example2.c */

extern char buf1[];             /* gets the SAME chunk of memory as from example.c */
static char buf2[256];          /* DIFFERENT 256 char buffer than example.c */
extern char * buf3 ;            /* Same pointer as from example.c */
void undoes() {
     free(buf3);                /* this will work as long as example() called first */
     return ;
}

и это оба пути потребовало бы использования свободных ().

Нет, только первые потребности использование свободного. Второе выделяется на стеке. Это делает его невероятно быстро для выделения.Послушайте:

void doit() {
    /* ... */
    /* SP += 10 * sizeof(int) */
    int a[10];
    /* ... (using a) */

} /* SP -= 10 */

При создании его компилятор во время компиляции знает свой размер и выделит правильный размер в стеке для него. Стек является большим блоком непрерывной памяти, расположенной где-нибудь. Помещение чего-то в стеке просто увеличит (или постепенно уменьшится в зависимости от Вашей платформы), stackpointer. Выход из объема сделает реверс, и Ваш массив освобожден. Это произойдет автоматически. Для этого переменные создали тот путь, имеют продолжительность автоматического хранения.

Используя malloc отличается. Это закажет некоторый произвольный блок памяти большой емкости (от места, названного freestore). Время выполнения будет иметь к поиску довольно большой блок памяти. Размер может быть определен во времени выполнения, таким образом, компилятор обычно не может оптимизировать его во время компиляции. Поскольку указатель может выйти из объема или быть скопирован вокруг, нет никакой свойственной связи между памятью, выделенной и указателем, которому присвоен адрес памяти, таким образом, память все еще выделяется даже при отъезде функции давно. Необходимо назвать бесплатную передачу его адресом, который Вы получили от malloc вручную, если время настало, чтобы сделать так.

Некоторая "недавняя" форма C, названного C99, позволяет Вам давать массивам размер во время выполнения. Т.е. Вам разрешают сделать:

void doit(int n) {
    int a[n]; // allocate n * sizeof(int) size on the stack */
}

Но той функции нужно лучше избежать, если у Вас нет причины использовать ее. Одна причина состоит в том, что это не отказоустойчиво: Если никакая память больше не доступна, что-либо может произойти. Другой - это, C99 не является очень портативным среди компиляторов.

Это неправильно - объявление массива не требует свободного. Далее, если это в функции, она выделяется на стеке (если не изменяет память), и автоматически выпущена с функциональными возвратами - не передают ссылку на него назад вызывающая сторона!

Сломайте свой оператор

char* name = malloc(256*sizeof(char)); // one statement
char *name; // Step 1 declare pointer to character
name = malloc(256*sizeof(char)); // assign address to pointer of memory from heap
name[2]; // access 3rd item in array
*(name+2); // access 3rd item in array
name++; // move name to item 1

Перевод: имя является теперь указателем на символ, которому присваивают адрес некоторой памяти на "куче"

char name[256]; // declare an array on the stack
name++; // error name is a constant pointer
*(name+2); // access 3rd item in array
name[2]; // access 3rd item in array
char *p = name;
p[2]; // access 3rd item in array
*(p+2); // access 3rd item in array
p++; // move p to item 1
p[0]; // item 1 in array

Перевод: Имя является постоянным указателем на символ, который указывает на некоторую память на стеке

В массивах C и указателях то же самое более или менее. Массивы являются постоянными указателями на память. Основное различие - то, что при вызове malloc, Вы берете свою память от "кучи", и любая память, взятая от "кучи", должна быть освобождена от "кучи". Когда Вы объявляете массив с размером, это - присвоенная память от стека. Вы не можете освободить эту память, потому что свободный сделан к свободной памяти из "кучи". Память на стеке будет автоматически освобождена, когда текущий программный модуль возвратится. Во втором примере, бесплатном (p), была бы ошибка также. p является указателем массив имени на стеке. Таким образом путем освобождения p Вас пытаются освободить память на стеке.

Это не отличается от:

int n = 10;
int *p = &n;

освобождение p в этом случае было бы ошибкой, потому что p указывает на n, который является переменной на стеке. Поэтому p содержит ячейку памяти в стеке и не может быть освобожден.

int *p = (int *) malloc(sizeof(int));
*p = 10;
free(p);

в этом случае свободное корректно, потому что p указывает на ячейку памяти на "куче", которая была выделена malloc.

в зависимости от того, где Вы выполняете это, стековое пространство могло бы быть в ОГРОМНОЙ премии. Например, при написании кода BREW для гарнитур Verizon/Alltel Вы обычно ограничиваетесь миниатюрными стеками, но имеете когда-либо увеличивающийся доступ "кучи".

Кроме того, как символ [] чаще всего используются для строк, это не плохая идея позволить строковому методу построения выделять память, в которой это нуждается для рассматриваемой строки, а не надежда, которая навсегда и всегда 256 (или безотносительно числа Вы устанавливаете декретом) будет достаточна.