С ++ const вопрос

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

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

Следует также отметить, что между

bar* const variable

и

const bar* variable

и

const bar* const variable

В первой форме указатель никогда не изменится, но вы можете редактировать объект, на который он указывает. Во второй форме вы можете редактировать указатель (навести его на другой объект), но не переменную, на которую он указывает. В окончательной форме вы не будете редактировать ни указатель, ни объект, на который он указывает. Справка

Чтобы добавить немного больше пояснений к заданному вопросу, вы всегда можете пообещать БОЛЬШЕ const, чем меньше. Учитывая класс:

class Foo {
    void func1 (int x);
    void func2 (int *x);
}

Вы можете скомпилировать следующую реализацию:

Foo::func1(const int x) {}
Foo::func2(const int *x) {}

или же:

Foo::func1(const int x) {}
Foo::func2(const int* const x) {}

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

В первом случае const влияет не на интерфейс, а только на реализацию. Вы говорите компилятору: «Я не собираюсь изменять значение bar* в этой функции». Вы все еще можете изменить то, на что указывает указатель. В последнем случае вы сообщаете компилятору (и всем вызывающим абонентам), что вы не будете изменять структуру bar, которую представляет собой bar*указывает на.

См. этот вопрос, этот вопрос и этот вопрос.

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

Итак, вторая константа в:

void Foo::foo(const bar* const);

Является ли нет частью сигнатуры метода?

Ключевое слово const в первом примере бессмысленно. Вы говорите, что не планируете менять указатель. Однако указатель был передан по значению, поэтому не имеет значения, измените вы его или нет; это не повлияет на вызывающего абонента. Точно так же вы также можете сделать это:

// In header 
class Foo {
void foo( int b );
};

// In cpp
void Foo::foo( const int b ) {
//Stuff
}

Вы даже можете сделать это:

// In header 
class Foo {
void foo( const int b );
};

// In cpp
void Foo::foo( int b ) {
//Stuff
}

Поскольку int передается по значению, постоянство не имеет значения.

Во втором примере вы говорите, что ваша функция принимает указатель на один тип, но затем реализует ее как указатель на другой тип, поэтому она терпит неудачу.

Это проще понять с типом переменной, отличным от указателя. Например, у вас может быть следующее объявление функции:

void foo( int i );

Определение может выглядеть так:

void foo( const int i ) { ... }

Независимо от того, является ли переменная 'i' константой на стороне определения, является деталью реализации. Это не влияет на клиентов этой функции.

Вероятно, он не особо заботится о void Foo::foo(bar* const pBar), потому что то, как вы относитесь к самому указателю (константа или нет), не имеет значения вне подпрограммы. Правила C говорят, что никакие изменения в pBar в любом случае не будут выходить за пределы foo.

Однако, если это (const bar* pBar), это имеет значение, потому что это означает, что компилятор не разрешает вызывающим объектам передавать указатели на неконстантные объекты.