Diferença entre usar ponteiros de caracteres e matrizes de caracteres

Question

Pergunta básica.

char new_str[]="";

char * newstr;

Se eu tiver que concatenar alguns dados para ele ou cordas uso funções como strcat / substr / strcpy, qual é a diferença entre os dois?

Eu entendo que eu tenho para alocar memória para o char * abordagem (Linha # 2). Eu não sou realmente certo como embora.

E const char * e strings literais são os mesmos?

Eu preciso saber mais sobre isso. Alguém pode apontar para algum bom conteúdo / material de exaustiva?

Answer 1

Por favor, vá através este artigo abaixo:

Veja também em caso de matriz de char como no seu caso, char new_str [] então o new_str sempre ponto para a base da matriz. O ponteiro em si não pode ser incrementado. Sim, você pode usar índices para acessar o próximo caractere em conjunto por exemplo: new_str[3];

new_str++ Mas no caso de ponteiro para char, o ponteiro pode ser incrementado para buscar-lhe o próximo caractere na matriz.

Também gostaria de sugerir este artigo para obter mais clareza .

Answer 2

O excelente fonte para esclarecer a confusão é Peter Van der Linden, Expert C Programming, segredos profundos C - que matrizes e ponteiros não são o mesmo é como eles são abordados na memória.

Com uma matriz,

char new_str[];

o compilador deu o new_str um endereço de memória que é conhecido tanto pelo compilação e de tempo de execução, por exemplo 0x1234, portanto, a indexação do new_str é simples usando []. Por exemplo new_str[4], em tempo de execução, o código escolhe o endereço de onde reside new_str em, por exemplo, 0x1234 (que é o endereço na memória física). adicionando o [4] índice especificador a ele, 0x1234 + 0x4, o valor pode ser recuperado.

Considerando que, com um ponteiro, o compilador dá o símbolo

char *newstr

um endereço por exemplo 0x9876, mas em tempo de execução, esse endereço usado, é um esquema de endereçamento indireto. Supondo que newstr foi

newstr = malloc(10);

malloc, o que está acontecendo é que, é feita toda vez que uma referência no código para uso newstr, uma vez que o endereço do newstr é conhecido pelo compilador ou seja, 0x9876, mas o que está apontando newstr para é variável. Em tempo de execução, o código obtém dados da memória física 0x9876 (ou seja newstr), mas nesse endereço é, um outro endereço de memória (uma vez que malloc-lo), por exemplo, 0x8765 é aqui, o código obtém os dados de que o endereço de memória que malloc atribuído a newstr, ou seja, 0x8765.

O char new_str[] e char *newstr são usados ??alternadamente, uma vez que um zeroth índice elemento dos decaimentos de matriz em um ponteiro e que explica por que você poderia newstr[5] ou *(newstr + 5) Observe como a expressão ponteiro é utilizado, embora tenhamos char *newstr declarou, portanto

*(new_str + 1) = *newstr;

OU

*(new_str + 1) = newstr[1];

Em resumo, a diferença real entre os dois é a forma como eles são acessados ??na memória.

Obter o livro e lê-lo e vivê-lo e respirá-lo. É um livro brilhante! :)

Answer 3

Este é um array de caracteres:

char  buf [1000];

Assim, por exemplo, isso não faz sentido:

buf = &some_other_buf;

Isto porque buf, embora tenha características de tipo ponteiro, já está apontando para o único lugar que faz sentido para ele.

char *ptr;

Por outro lado, ptr apenas um ponteiro, e pode apontar algum lugar. Na maioria das vezes, é algo como isto:

ptr = buf;              // #1:  point to the beginning of buf, same as &buf[0]

ou talvez isto:

ptr = malloc (1000);    // #2:  allocate heap and point to it

ou

ptr = "abcdefghijklmn"; // #3:  string constant

Para todos estes, * ptr podem ser gravados, exceto o terceiro caso em que algum ambiente compilar definir constantes de string para ser reescrito.

*ptr++ = 'h';          // writes into #1: buf[0], #2: first byte of heap, or
                       //             #3 overwrites "a"
strcpy (ptr, "ello");  // finishes writing hello and adds a NUL

Answer 4

A diferença é que uma é um ponteiro, o outro é uma matriz. Você pode, por exemplo, sizeof () array. Você pode estar interessado em espreitar aqui

Answer 5

Se você estiver usando C ++ como suas tags indicam, você realmente deve estar usando o C ++ cordas, não o matrizes C char.

O tipo string faz manipulação de cordas muito mais fácil.

Se você está preso com matrizes char, por algum motivo, a linha:

char new_str[] = "";

aloca 1 byte de espaço e coloca um caractere nulo terminador para ele. É sutilmente diferente:

char *new_str = "";

desde que podem lhe dar uma referência para a memória não-gravável. A declaração:

char *new_str;

em seu próprio dá-lhe um ponteiro, mas nada que ele aponta. Ele também pode ter um valor aleatório que seja local para uma função.

O que as pessoas tendem a fazer (em C em vez de C ++) é fazer algo como:

char *new_str = malloc (100); // (remember that this has to be freed) or
char new_str[100];

para obter espaço suficiente.

Se você usar as funções str..., você está basicamente responsável por garantir que você tem espaço suficiente na matriz char, para que você não obter todos os tipos de prática estranha e maravilhosa na depuração de código. Se você usar o verdadeiro C ++ cordas, uma grande parte do trabalho pesado é feito para você.

Answer 6

O tipo do primeiro é char [1], o segundo é char *. Diferentes tipos.

Alocar memória para o último com malloc em C, ou new em C ++.

char foo[] = "Bar";  // Allocates 4 bytes and fills them with
                     // 'B', 'a', 'r', '\0'.

O tamanho aqui está implícito a partir da cadeia initializer.

O conteúdo do foo são mutáveis. Você pode alterar foo[i] por exemplo, quando i = 0..3.

OTOH se você fizer isso:

char *foo = "Bar";

O compilador agora aloca uma corda estática "Bar" na memória somente leitura e não pode ser modificado.

foo[i] = 'X';  // is now undefined.

Answer 7

char new_str[]="abcd";  

Especifica uma matriz de caracteres (string) de tamanho 5 bytes (um byte para cada caractere mais um para o terminador nulo). Então, ele armazena a string 'abcd' na memória e podemos acessar essa string usando o new_str variável.

char *new_str="abcd";  

Isto especifica uma string 'abcd' é armazenado em algum lugar na memória e os pontos de ponteiro new_str para o primeiro caractere dessa string.

Answer 8

Para diferenciá-los no lado da alocação de memória:

// With char array, "hello" is allocated on stack
char s[] = "hello";

// With char pointer, "hello" is stored in the read-only data segment in C++'s memory layout.
char *s = "hello";

// To allocate a string on heap, malloc 6 bytes, due to a NUL byte in the end
char *s = malloc(6);
s = "hello";

Answer 9

Se você estiver em c ++ por que não usar std :: string para todas as suas necessidades corda? Especialmente qualquer coisa lidar com concatenação. Isto irá salvá-lo de um monte de problemas.