What is the difference between char name[] and char* name in C?

A fundamental difference is that in the case of the pointer it points to a string literal. Attempting to modify it is undefined behavior.

While in the other case the array contains a copy of the string that is modifiable.

The fact that a string literal is not modifiable allows compilers to make certain optimizations. If a string is repeated in code and is used as a literal, the compiler can use the same copy of the string for all uses, reducing memory usage. It can also be used directly, which is faster.

For example, this C program:

#include<stdio.h>
void f() {
  char* name = "Gerardo";
  puts(name);
}

int main(void) {
  char* name = "Gerardo";
  puts(name);
  return 0;
}

The compiled assembly code (leaving only the relevant parts):

.LC0:
        .string "Gerardo"     <----- Aparece solo una vez
        .section        .text.unlikely,"ax",@progbits

f:
.LFB23:
        .cfi_startproc
        movl    $.LC0, %edi <---- Ponemos la dirección de la cadena en edi
        jmp     puts        <---- Y puts usa la cadena desde ahí directamente
        .cfi_endproc

main:
.LFB24:
        .cfi_startproc
        subq    $8, %rsp
        .cfi_def_cfa_offset 16
        movl    $.LC0, %edi   <------- Main usa la misma cadena
        call    puts

However the same program using arrays :

void f() {
  char name[] = "Gerardo";
  puts(name);
}
int main(void) {
  char name[] = "Gerardo";
  puts(name);
  return 0;
}

When compiling it:

f:
.LFB23:
        .cfi_startproc
        subq    $24, %rsp          <----- Hay que reservar espacio en la pila
        .cfi_def_cfa_offset 32     
        movq    %fs:40, %rax
        movq    %rax, 8(%rsp)
        xorl    %eax, %eax
        movq    %rsp, %rdi
        movabsq $31354164838819143, %rax <--- Hay que copiar la cadena a la pila;
                                         <--- Esto lleva tiempo y ocupa espacio
        movq    %rax, (%rsp)
        call    puts

main:
.LFB24:
        .cfi_startproc
        subq    $24, %rsp           <------ Reservando espacio en la pila
        .cfi_def_cfa_offset 32
        movq    %fs:40, %rax
        movq    %rax, 8(%rsp)
        xorl    %eax, %eax
        movq    %rsp, %rdi
        movabsq $31354164838819143, %rax  <--- Gerardo está 2 veces en el binario
        movq    %rax, (%rsp)
        call    puts

To compile those examples I have used gcc -c -S -O2 fichero.c(version 5.4.0)

Conclusion . If you are not going to modify the string, the alternative of the string literal assigned to a pointer is faster and uses less memory. If you are going to modify the string you should use the array.

Character pointers are normally used to access character strings, since these are built on the basis of an address (that of the first character) and an end-of-string marker (the '\0' character). The declaration of a character pointer follows the usual rules:

char * puntero_caracter;

String Pointers: Definition, Declaration and Initialization. The declaration of a string can be as follows:

char cadena[LONGITUD];

This reserves space for a string of LENGTH characters.

In C, the name of a one-dimensional list is equal to the address of the first element in the list. Once reserved space is available for the string, a pointer to the string can be constructed using the following statements:

char * p;
char cadena[LONGITUD];
p = cadena;/* Esto equivale, desde luego, a poner: */
p = &cadena[0];

Ref.

http://maxus.fis.usal.es/fichas_c.web/07xx_PAGS/0702.html

Pointers to char access character strings with the address of the 1st element in the string, that string ends with '\0'(end-of-string character). When you do ++it advances to the next address in the string (next character).

char arrays are a pointer to the 1st character of the string. Therefore, from the point of view of how they are stored in memory, there is no difference. The difference is in the syntax, and there using array-type syntax is better, because when using pointer syntax the compiler must resolve the overload of the operator *since it is also used for multiplications and that affects performance a bit in execution and compilation .

Also using arrays is easier for the human eye. The syntax is more understandable with arrays than with pointers.