В чем разница между char * const и const char *?

в чем разница между:

char * const

и

const char *
231
c const pointers

18 ответов

разница в том, что const char * указатель на const char, а char * const является постоянным указателем на char.

во-первых, указываемое значение не может быть изменено, но указатель может быть. Во-вторых, указываемое значение может изменяться, но указатель не может (аналогично ссылке).

также

const char * const

постоянный указатель на константу типа char (так что об этом не может быть измененный.)

Примечание:

следующие две формы эквивалентны:

const char *

и

char const *

точная причина этого описана в стандарте C++, но важно заметить и избежать путаницы. Я знаю несколько стандартов кодирования, которые предпочитают:

char const

над

const char

(с указателем или без него) так, чтобы размещение const элемент такой же, как с указателем const.

303

чтобы избежать путаницы, всегда добавить квалификатор const.

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;
86

const всегда изменяет то, что приходит перед ним (слева от него), за исключением случаев, когда это первое в объявлении типа, где он изменяет то, что приходит после него (справа от него).

Итак, эти двое-одно и то же:

int const *i1;
const int *i2;

они определяют указатели на const int. Вы можете изменить, где i1 и i2 очки, но вы не можете изменить значение, на которое они указывают.

это:

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

определяет const указатель к целому числу и инициализирует его, чтобы указать на местоположение памяти 12345678. Вы можете изменить int значение по адресу 12345678, но вы не можете изменить адрес, что i3 указывает.

31

const * char является недопустимым кодом C и бессмысленным. Возможно, вы хотели спросить разницу между a const char * и char const *, или, возможно, разница между const char * и char * const?

Читайте также:

21

const char* - указатель на постоянный символ
char* const является постоянным указателем на символ
const char* const является постоянным указателем на постоянный символ

13

1) const char * x здесь X-это в основном указатель символов, который указывает на постоянное значение

2) char * const x относится к указателю символа, который является постоянным, но местоположение, на которое он указывает, может быть изменено.

3) const char* const x является комбинацией 1 и 2, означает, что это указатель постоянного символа, который указывает на постоянное значение.

4) const *char x вызовет ошибка компилятора. он не может быть объявлен.

5) char const * x равно пункту 1.

эмпирическое правило: если const С именем var тогда указатель будет постоянным, но местоположение указателя может быть изменено, else указатель будет указывать на постоянное местоположение, а указатель может указывать на другое местоположение, но содержимое указывающего местоположения не может быть изменено.

8

правило: прочитайте определение справа налево!

const int *foo;

значит "foo точки (*) к int это не может измениться (const)".
Для программиста это означает "Я не буду менять стоимостью что foo очков".

  • *foo = 123; или foo[0] = 123; будет недействительным.
  • foo = &bar; is допустимый.

int *const foo;

значит "foo не может изменить (const) и точки (*) к int".
Для программиста это означает "Я не буду менять адрес в памяти это foo относится к".

  • *foo = 123; или foo[0] = 123; разрешено.
  • foo = &bar; будет недействительным.

const int *const foo;

значит "foo не может изменить (const) и очки (*) к int это не может измениться (const)".
Для программиста это означает "Я не буду менять стоимостью что foo очков, ни я изменить адрес это foo относится к".

  • *foo = 123; или foo[0] = 123; будет недействительным.
  • foo = &bar; будет недействительным.
5

первый-синтаксическая ошибка. Возможно, вы имели в виду разницу между

const char * mychar

и

char * const mychar

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

3

другое правило большого пальца-проверить, где const является:

  1. до * =>стоимостью хранятся постоянный
  2. после * =>указатель и постоянный
3

много ответов дают конкретные методы, правила тумб и т. д., Чтобы понять этот конкретный экземпляр переменной. Но есть общая техника понимания любого объявления:

По Часовой Стрелке / Спиральное Правило

A)

const char *a;

согласно правилу по часовой стрелке / спирали a - это указатель на символ, который является постоянным. Это означает, что символ постоянен, но указатель можете изменить. т. е. a = "other string"; - это хорошо, но a[2] = 'c'; не будет компилироваться

B)

char * const a;

как правило, a является указателем const на символ. то есть вы можете сделать a[2] = 'c'; но вы не можете сделать a = "other string";

2

Я полагаю, вы имеете в виду const char * и char * const .

первый, const char *, является указателем на постоянный символ. Сам указатель является изменяемым.

второй, char * const является постоянным указателем на символ. Указатель не может изменить характер его очков может.

и тогда есть const char * const, где указатель и символ не могут измениться.

1

вот подробное объяснение с кодом

/*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;
}*/
1
  1. постоянный указатель: постоянный указатель может указывать только на одну переменную соответствующего типа данных в ходе всей программы.мы можем изменить значение переменной, на которую указывает указатель. Инициализация должна производиться во время самого объявления.

синтаксис:

datatype *const var;

char *const подпадает под этот случай.

/*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;
}
  1. указатель на значение const: в этом указатель может точка любого числа переменных соответствующего типа, но мы не можем изменить значение объекта, на который указывает указатель в определенное время.

синтаксис:

const datatype *varили datatype const *var

const char* подпадает под это дело.

/* 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;
    }
1

char * const и const char*?

  1. указывая на постоянное значение

const char * p; // значение не может быть изменено

  1. постоянный указатель на значение

char * const p; / / - адрес не может быть изменен

  1. постоянный указатель на постоянное значение

const char * const p; / / оба не могут быть изменены.

1

на const модификатор применяется к термину непосредственно слева от него. Единственное исключение-когда слева от него ничего нет, тогда оно относится к тому, что находится справа.

это все эквивалентные способы сказать "постоянный указатель на константу char":

  • const char * const
  • const char const *
  • char const * const
  • char const const *
1

два правила

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

например

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

Я хотел бы отметить, что использование int const * (или const int *) не о указателе, указывающем на const int переменная, но эта переменная const для этого конкретного указателя.

например:

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

код выше компилируется отлично. _p точки const переменной, хотя var сам по себе не является постоянным.

1
// 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’
}
0