Должны бесполезные спецификаторы типа на типах возврата использоваться для ясности?

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

#define CONST_RETURN

CONST_RETURN int foo();

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

Да. Я бы посоветовал писать код «явно», потому что он дает понять всем (включая вас) при чтении кода, что вы имели в виду. Вы пишете код для других программистов, чтобы они читали , а не для удовлетворения прихоти компилятора и инструментов статического анализа!

(Однако вы должны быть осторожны, чтобы любой такой «ненужный код» не был приводит к генерации другого кода!)

Некоторые примеры явного кодирования, улучшающего читаемость / ремонтопригодность:

• Я заключаю в скобки части арифметических выражений, чтобы явно указать, что я хочу сделать. Это дает понять любому читателю, что я имел в виду, и избавляет меня от необходимости беспокоиться (или делать ошибки с) правилами приоритета:

   int a = b + c * d / e + f; // Трудно читать - нужно знать приоритет
  int a = b + ((c * d) / e) + f; // Легко читать - ясные явные вычисления
  

• In C++, if you override a virtual function, then in the derived class you can declare it without mentioning "virtual" at all. Anyone reading the code can't tell that it's a virtual function, which can be disastrously misleading! However you can safely use the virtual keyword:

  virtual int MyFunc()

  and this makes it clear to anyone reading your class header that this method is virtual. (This "C++ syntax bug" is fixed in C# by requiring the use of the "override" keyword in this case - more proof if anyone needed it that missing out the "unnecessary virtual" is a really bad idea)

These are both clear examples where adding "unnecessary" code will make the code more readable and less prone to bugs.

Если пока игнорировать const , foo () возвращает значение. Вы можете выполнить

int x = foo();

и присвоить значение, возвращаемое foo () , переменной x почти так же, как вы можете сделать

int x = 42;

, чтобы присвоить значение 42 в переменную x.
Но вы не можете изменить 42 ... или значение, возвращаемое foo () . Заявление о том, что значение, возвращаемое из foo () , не может быть изменено путем применения ключевого слова const к типу foo () ничего не дает.

Значения не может быть const ( или restrict , или volatile ). Только объекты могут иметь квалификаторы типа.

В отличие от

const char *foo();

В этом случае foo () возвращает указатель на объект. Объект, на который указывает возвращаемое значение, может быть квалифицирован как const .

const int foo () сильно отличается от const char * foo () . const char * foo () возвращает массив (обычно строку), содержимое которого не может изменяться. Подумайте о разнице между:

 const char* a = "Hello World";

и

const int b = 1;

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

const char* foo();
const char* a = "Hello World\n";
a = foo();

разрешен, но

const int bar();
const int b = 0;
b = bar();

не разрешен, даже с объявлением const для bar () .

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

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