Почему выпадение из конца непустой функции без возврата значения не приводит к ошибке компилятора?

С тех пор, как я понял много лет назад, что это не приводит к ошибке по умолчанию (по крайней мере, в GCC), я всегда задавался вопросом, почему?

Я понимаю, что вы можете использовать флаги компилятора для выдачи предупреждения, но не должно ли это быть ошибкой? Почему имеет смысл, чтобы не пустая функция не возвращала значение, чтобы быть действительным?

Пример в соответствии с просьбой в комментариях:

#include <stdio.h>
int stringSize()
{
}

int main()
{
    char cstring[5];
    printf( "the last char is: %c\n", cstring[stringSize()-1] ); 
    return 0;
}

... компилирует.

Стандарты C99 и C ++ не требуют, чтобы функции возвращали значение. Отсутствующий оператор возврата в функции, возвращающей значение, будет определен (возвращаться 0) только в mainфункции.

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

Из C ++ 11 черновик:

§ 6.6.3 / 2

Перетекание из конца функции [...] приводит к неопределенному поведению в функции, возвращающей значение.

§ 3.6.1 / 5

Если контроль достигает конца, mainне встречая return оператора, эффект заключается в выполнении

return 0;

Обратите внимание, что поведение, описанное в C ++ 6.6.3 / 2, отличается от поведения в C.

gcc выдаст вам предупреждение, если вы вызовете его с опцией -Wreturn-type.

Wreturn-type Предупреждать всякий раз, когда функция определена с типом возвращаемого значения, по умолчанию int. Также предупредите о любом операторе возврата без возвращаемого значения в функции, чей тип возврата не является пустым (падение конца тела функции считается возвращаемым без значения), а также об операторе возврата с выражением в функции, Возвращаемый тип void.

Это предупреждение включено -Wall .

Просто для любопытства посмотрите, что делает этот код:

#include <iostream>

int foo() {
   int a = 5;
   int b = a + 1;
}

int main() { std::cout << foo() << std::endl; } // may print 6

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

По умолчанию gcc не проверяет, что все пути кода возвращают значение, потому что в общем случае это невозможно. Предполагается, что вы знаете, что делаете. Рассмотрим общий пример с использованием перечислений:

Color getColor(Suit suit) {
    switch (suit) {
        case HEARTS: case DIAMONDS: return RED;
        case SPADES: case CLUBS:    return BLACK;
    }

    // Error, no return?
}

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

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

char getChoice() {
    int ch = read();

    if (ch == -1 || ch == 'q') {
        System.exit(0);
    }
    else {
        return (char) ch;
    }

    // Cannot reach here, but still an error.
}

Это философская разница. C и C ++ являются более разрешающими и доверчивыми языками, чем Java или C #, поэтому некоторые ошибки в более новых языках являются предупреждениями в C / C ++, а некоторые предупреждения игнорируются или отключаются по умолчанию.

Вы имеете в виду, почему утечка из конца функции, возвращающей значение (т.е. выход без явного return) не является ошибкой?

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

Во-вторых, очевидно, языковая спецификация не хотела заставлять авторов компилятора обнаруживать и проверять все возможные пути управления на наличие явного return(хотя во многих случаях это не так сложно сделать). Кроме того, некоторые пути управления могут привести к невозвратным функциям - черта, которая обычно не известна компилятору. Такие пути могут стать источником досадных ложных срабатываний.

Также обратите внимание, что C и C ++ различаются в своих определениях поведения в этом случае. В C ++ просто выход из конца функции, возвращающей значение, всегда является неопределенным поведением (независимо от того, используется ли результат функции вызывающим кодом). В C это вызывает неопределенное поведение, только если вызывающий код пытается использовать возвращаемое значение.

Под C / C ++ разрешено не возвращаться из функции, которая утверждает, что что-то возвращает. Существует ряд вариантов использования, таких как вызов exit(-1)или функция, которая вызывает его или выдает исключение.

Компилятор не собирается отказываться от легального C ++, даже если он ведет к UB, если вы просите об этом. В частности, вы просите об отсутствии предупреждений . (Gcc по-прежнему включает некоторые по умолчанию, но когда они добавляются, они, похоже, соответствуют новым функциям, а не новым предупреждениям для старых функций)

Изменение по умолчанию no-arg gcc для выдачи некоторых предупреждений может быть серьезным изменением для существующих скриптов или систем. Хорошо продуманные или -Wallимеют дело с предупреждениями, или переключают отдельные предупреждения.

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

Я считаю, что это из-за унаследованного кода (C никогда не требовал оператора return, как и C ++). Вероятно, существует огромная кодовая база, опирающаяся на эту «функцию». Но по крайней мере есть -Werror=return-type флаг на многих компиляторах (включая gcc и clang).

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

double pi()
{
    __asm fldpi
}

Эта функция возвращает пи с использованием сборки x86. В отличие от сборки в GCC, я не знаю способа использовать returnэто, не задействуя в результате издержки.

Насколько я знаю, основные компиляторы C ++ должны выдавать как минимум предупреждения для явно некорректного кода. Если я сделаю тело pi()пустым, GCC / Clang сообщит о предупреждении, а MSVC сообщит об ошибке.

Люди упоминали об исключениях и exitв некоторых ответах. Это не веские причины. Вызов исключения или вызов неexit приведут к потере выполнения функции. И компиляторы знают это: написание оператора throw или обращения к пустому телу остановит все предупреждения или ошибки от компилятора.exitpi()

При каких обстоятельствах это не приводит к ошибке? Если он объявляет тип возвращаемого значения и ничего не возвращает, для меня это звучит как ошибка.

Единственное исключение, о котором я могу подумать, - это main()функция, которая вообще не нуждается в returnвыражении (по крайней мере, в C ++; у меня нет под рукой ни одного из стандартов C). Если нет возврата, он будет действовать так, как будто return 0;это последнее утверждение.

Похоже, вам нужно включить предупреждения вашего компилятора:

$ gcc -Wall -Wextra -Werror -x c -
int main(void) { return; }
cc1: warnings being treated as errors
<stdin>: In function ‘main’:
<stdin>:1: warning: ‘return’ with no value, in function returning non-void
<stdin>:1: warning: control reaches end of non-void function
$

Это нарушение ограничений в c99, но не в c89. Контраст:

c89:

3.6.6.4 returnУтверждение

Ограничения

returnЗаявление с выражением не должны появляться в функции которого возвращаемый тип void.

c99:

6.8.6.4 returnУтверждение

Ограничения

returnЗаявление с выражением не должны появляться в функции которого возвращаемый тип void. returnЗаявление без выражения должны появляться только в функции которого возвращаемый тип void.

Даже в --std=c99режиме gcc выдаст только предупреждение (хотя без необходимости включать дополнительные -Wфлаги, как требуется по умолчанию или в c89 / 90).

Отредактируйте, чтобы добавить это в c89, «достижение того, }что завершает функцию, эквивалентно выполнению returnоператора без выражения» (3.6.6.4). Однако в c99 поведение не определено (6.9.1).