Why do you declare a string as char asterisk?

Answer 1

Declaring strings as char* is generally faster than declaring an array of type char.

Consider the following:

#include<stdio.h>

int main (void) {

char c1[12] = "Hello world";

char c2[] = "Hello world";

char* c3 = "Hello world";

// ...

return 0;

}

The string literal, "Hello world" is duplicated three times in the source code but in the resultant machine code that string only appears once (in the data segment). This is known as string-pooling; it makes no sense to maintain separate copies of the exact same value in the data segment.

Given that there is only one copy of the string, it would be natural to assume that c1, c2 and c3 all refer to the same memory location but they don't. In fact, the only one that does refer to the data segment copy is the third one.

If we examine the assembly for the c1 initialisation we find the following:

mov eax, DWORD PTR ??_C@_0M@KIBDPGDE@Hello?5world?$AA@

mov DWORD PTR _c1$[ebp], eax

mov ecx, DWORD PTR ??_C@_0M@KIBDPGDE@Hello?5world?$AA@+4

mov DWORD PTR _c1$[ebp+4], ecx

mov edx, DWORD PTR ??_C@_0M@KIBDPGDE@Hello?5world?$AA@+8

mov DWORD PTR _c1$[ebp+8], edx

The symbol ??_C@_0M@KIBDPGDE@Hello?5world?$AA@ identifies the string in the data segment but the assembly clearly shows data is being copied (moved) to a new location 32-bits (4 bytes) at a time. The new location is the address of c1. The same thing happens for c2, making yet another copy of the string.

However the c3 initialisation consists of just one instruction.

mov DWORD PTR _c3$[ebp], OFFSET ??_C@_0M@KIBDPGDE@Hello?5world?$AA@

The difference is that instead of copying the string to new memory, we simply copy the address of the string.

This is low-level stuff of course, but it makes no sense to copy objects from the data segment or indeed anywhere else when we can simply refer to them directly using a pointer. We only need to copy objects when we actually intend to make some change to the object without affecting the original object. In all other cases we can simply refer to them.

Answer 2

The asterisk denotes that the variable is a pointer to the type, not the type itself. Thus instead of allocating memory for a single char (1 byte), you allocate memory for a pointer (typically 4 bytes on a 32-bit system) to a char.

A string is an array of char. In order to reference an array you need to know the start address of the array as well as the number of elements in the array. We don't need to know the length of a string because all strings must be null-terminated, so we only need the start address, which we simply store in a character pointer variable (a variable of type char*). This tells the compiler that the variable holds an address and that the address holds a character, the first character in the string.