What is the difference between char * const and const char *?

C Problem Overview

What's the difference between:

char * const

and

const char *

C Solutions

Solution 1 - C

The difference is that const char * is a pointer to a const char, while char * const is a constant pointer to a char.

The first, the value being pointed to can't be changed but the pointer can be. The second, the value being pointed at can change but the pointer can't (similar to a reference).

There is also a

const char * const

which is a constant pointer to a constant char (so nothing about it can be changed).

Note:

The following two forms are equivalent:

const char *

and

char const *

The exact reason for this is described in the C++ standard, but it's important to note and avoid the confusion. I know several coding standards that prefer:

char const

over

const char

(with or without pointer) so that the placement of the const element is the same as with a pointer const.

Solution 2 - C

To avoid confusion, always append the const qualifier.

int       *      mutable_pointer_to_mutable_int;
int const *      mutable_pointer_to_constant_int;
int       *const constant_pointer_to_mutable_int;
int const *const constant_pointer_to_constant_int;

Solution 3 - C

const always modifies the thing that comes before it (to the left of it), EXCEPT when it's the first thing in a type declaration, where it modifies the thing that comes after it (to the right of it).

So these two are the same:

int const *i1;
const int *i2;

they define pointers to a const int. You can change where i1 and i2 points, but you can't change the value they point at.

This:

int *const i3 = (int*) 0x12345678;

defines a const pointer to an integer and initializes it to point at memory location 12345678. You can change the int value at address 12345678, but you can't change the address that i3 points to.

Solution 4 - C

const char* is a pointer to a constant character
char* const is a constant pointer to a character
const char* const is a constant pointer to a constant character

Solution 5 - C

const * char is invalid C code and is meaningless. Perhaps you meant to ask the difference between a const char * and a char const *, or possibly the difference between a const char * and a char * const?

Solution 6 - C

Rule of thumb: read the definition from right to left!

`const int *foo;`

Means "foo points (*) to an int that cannot change (const)".
To the programmer this means "I will not change the value of what foo points to".

*foo = 123; or foo[0] = 123; would be invalid.
foo = &bar; is allowed.

`int *const foo;`

Means "foo cannot change (const) and points (*) to an int".
To the programmer this means "I will not change the memory address that foo refers to".

*foo = 123; or foo[0] = 123; is allowed.
foo = &bar; would be invalid.

`const int *const foo;`

Means "foo cannot change (const) and points (*) to an int that cannot change (const)".
To the programmer this means "I will not change the value of what foo points to, nor will I change the address that foo refers to".

*foo = 123; or foo[0] = 123; would be invalid.
foo = &bar; would be invalid.

Solution 7 - C

const char x* Here X is basically a character pointer which is pointing to a constant value
char const x* is refer to character pointer which is constant, but the location it is pointing can be change.
const char const x* is combination to 1 and 2, means it is a constant character pointer which is pointing to constant value.
*const char x will cause a compiler error. it can not be declared.
char const * x is equal to point 1.

the rule of thumb is if const is with var name then the pointer will be constant but the pointing location can be changed , else pointer will point to a constant location and pointer can point to another location but the pointing location content can not be change.

Solution 8 - C

Another thumb rule is to check where const is:

**before *** => value stored is constant
**after *** => pointer itself is constant

Solution 9 - C

First one is a syntax error. Maybe you meant the difference between

const char * mychar

and

char * const mychar

In that case, the first one is a pointer to data that can't change, and the second one is a pointer that will always point to the same address.

Solution 10 - C

Lots of answer provide specific techniques, rule of thumbs etc to understand this particular instance of variable declaration. But there is a generic technique of understand any declaration:

Clockwise/Spiral Rule

const char *a;

As per the clockwise/spiral rule a is pointer to character that is constant. Which means character is constant but the pointer can change. i.e. a = "other string"; is fine but a[2] = 'c'; will fail to compile

char * const a;

As per the rule, a is const pointer to a character. i.e. You can do a[2] = 'c'; but you cannot do a = "other string";

Solution 11 - C

*char * const and const char ?

Pointing to a constant value

const char * p; // value cannot be changed

Constant pointer to a value

char * const p; // address cannot be changed

Constant pointer to a constant value

const char * const p; // both cannot be changed.

Solution 12 - C

I presume you mean const char * and char * const .

The first, const char *, is a pointer to a constant character. The pointer itself is mutable.

The second, char * const is a constant pointer to a character. The pointer cannot change, the character it points to can.

And then there is const char * const where the pointer and character cannot change.

Solution 13 - C

Here is a detailed explanation with code

/*const char * p;
char * const p; 
const char * const p;*/ // these are the three conditions,

// const char *p;const char * const p; pointer value cannot be changed

// char * const p; pointer address cannot be changed

// const char * const p; both cannot be changed.

#include<stdio.h>

/*int main()
{
	const char * p; // value cannot be changed
	char z;
	//*p = 'c'; // this will not work
	p = &z;
	printf(" %c\n",*p);
	return 0;
}*/

/*int main()
{
	char * const p; // address cannot be changed
	char z;
	*p = 'c'; 
	//p = &z;	// this will not work
	printf(" %c\n",*p);
	return 0;
}*/



/*int main()
{
	const char * const p; // both address and value cannot be changed
	char z;
	*p = 'c'; // this will not work
	p = &z;	// this will not work
	printf(" %c\n",*p);
	return 0;
}*/

Solution 14 - C

// Some more complex constant variable/pointer declaration.
// Observing cases when we get error and warning would help
// understanding it better.

int main(void)
{
  char ca1[10]= "aaaa"; // char array 1
  char ca2[10]= "bbbb"; // char array 2

  char *pca1= ca1;
  char *pca2= ca2;

  char const *ccs= pca1;
  char * const csc= pca2;
  ccs[1]='m';  // Bad - error: assignment of read-only location ‘*(ccs + 1u)’
  ccs= csc;    // Good

  csc[1]='n';  // Good
  csc= ccs;    // Bad - error: assignment of read-only variable ‘csc’

  char const **ccss= &ccs;     // Good
  char const **ccss1= &csc;    // Bad - warning: initialization from incompatible pointer type

  char * const *cscs= &csc;    // Good
  char * const *cscs1= &ccs;   // Bad - warning: initialization from incompatible pointer type

  char ** const cssc=   &pca1; // Good
  char ** const cssc1=  &ccs;  // Bad - warning: initialization from incompatible pointer type
  char ** const cssc2=  &csc;  // Bad - warning: initialization discards ‘const’
                               //                qualifier from pointer target type

  *ccss[1]= 'x'; // Bad - error: assignment of read-only location ‘**(ccss + 8u)’
  *ccss= ccs;    // Good
  *ccss= csc;    // Good
  ccss= ccss1;   // Good
  ccss= cscs;    // Bad - warning: assignment from incompatible pointer type

  *cscs[1]= 'y'; // Good
  *cscs= ccs;    // Bad - error: assignment of read-only location ‘*cscs’
  *cscs= csc;    // Bad - error: assignment of read-only location ‘*cscs’
  cscs= cscs1;   // Good
  cscs= cssc;    // Good

  *cssc[1]= 'z'; // Good
  *cssc= ccs;    // Bad - warning: assignment discards ‘const’
                 //                qualifier from pointer target type
  *cssc= csc;    // Good
  *cssc= pca2;   // Good
  cssc= ccss;    // Bad - error: assignment of read-only variable ‘cssc’
  cssc= cscs;    // Bad - error: assignment of read-only variable ‘cssc’
  cssc= cssc1;   // Bad - error: assignment of read-only variable ‘cssc’
}

Solution 15 - C

Constant pointer: A constant pointer can point only to a single variable of the respective data type during the entire program.we can change the value of the variable pointed by the pointer. Initialization should be done during the time of declaration itself.

Syntax:

datatype *const var;

char *const comes under this case.

/*program to illustrate the behaviour of constant pointer */

#include<stdio.h>
int main(){
  int a=10;
  int *const ptr=&a;
  *ptr=100;/* we can change the value of object but we cannot point it to another variable.suppose another variable int b=20; and ptr=&b; gives you error*/
  printf("%d",*ptr);
  return 0;
}

2. Pointer to a const value: In this a pointer can point any number of variables of the respective type but we cannot change the value of the object pointed by the pointer at that specific time.

Syntax:

const datatype *varor datatype const *var

const char* comes under this case.

/* program to illustrate the behavior of pointer to a constant*/

   #include<stdio.h>
   int main(){
       int a=10,b=20;
       int const *ptr=&a;
       printf("%d\n",*ptr);
       /*  *ptr=100 is not possible i.e we cannot change the value of the object pointed by the pointer*/
       ptr=&b;
       printf("%d",*ptr);
       /*we can point it to another object*/
       return 0;
    }

Solution 16 - C

The const modifier is applied to the term immediately to its left. The only exception to this is when there is nothing to its left, then it applies to what is immediately on its right.

These are all equivalent ways of saying "constant pointer to a constant char":

const char * const
const char const *
char const * const
char const const *

Solution 17 - C

Two rules

If const is between char and *, it will affect the left one.
If const is not between char and *, it will affect the nearest one.

e.g.

char const *. This is a pointer points to a constant char.
char * const. This is a constant pointer points to a char.

Solution 18 - C

I would like to point out that using int const * (or const int * ) isn't about a pointer pointing to a const int variable, but that this variable is const for this specific pointer.

For example:

int var = 10;
int const * _p = &var;

The code above compiles perfectly fine. _p points to a const variable, although var itself isn't constant.

Solution 19 - C

I remember from Czech book about C: read the declaration that you start with the variable and go left. So for

char * const a;

you can read as: "a is variable of type constant pointer to char",

char const * a;

you can read as: "a is a pointer to constant variable of type char. I hope this helps.

Bonus:

const char * const a;

You will read as a is constant pointer to constant variable of type char.

Content Type	Original Author	Original Content on Stackoverflow
Question	LB.	View Question on Stackoverflow
Solution 1 - C	workmad3	View Answer on Stackoverflow
Solution 2 - C	diapir	View Answer on Stackoverflow
Solution 3 - C	Don McCaughey	View Answer on Stackoverflow
Solution 4 - C	Andrew Coleson	View Answer on Stackoverflow
Solution 5 - C	Adam Rosenfield	View Answer on Stackoverflow
Solution 6 - C	Mr. Llama	View Answer on Stackoverflow
Solution 7 - C	AAnkit	View Answer on Stackoverflow
Solution 8 - C	Aadishri	View Answer on Stackoverflow
Solution 9 - C	Javier	View Answer on Stackoverflow
Solution 10 - C	JamesWebbTelescopeAlien	View Answer on Stackoverflow
Solution 11 - C	Yogeesh H T	View Answer on Stackoverflow
Solution 12 - C	Michael	View Answer on Stackoverflow
Solution 13 - C	Megharaj	View Answer on Stackoverflow
Solution 14 - C	gopalshankar	View Answer on Stackoverflow
Solution 15 - C	Goutham Gundapu	View Answer on Stackoverflow
Solution 16 - C	galois	View Answer on Stackoverflow
Solution 17 - C	Xinpei Zhai	View Answer on Stackoverflow
Solution 18 - C	SteliosKts	View Answer on Stackoverflow
Solution 19 - C	Sany	View Answer on Stackoverflow