[C] void test() {} - По стантарту при вызове аргументы не проверяются. Почему?

> я вижу только возможность сделать ошибку.

примеры будут или как?

Можно предположить, что для совместимости с достандартным С (который K&R C), в котором прототипов функций просто не было. А с помощью препроцессора можно получить код, который бы компилировался всеми компиляторами.

Думаю, это по историческим причинам. Когда-то в Си вообще не проверялись типы аргументов, а прототип функции писался «тип имя();». Потом эта форма стала обозначать «функция, принимающая любой число любых параметров» для сохранения совместимости с существующим кодом.

Я писал:

Ведь ясно же, что если программист передает аргументы в функцию, которая не принимает аргументов, то этот программист делает какую-то фигню.

Или нет, не ясно?

Ну вот простейший пример http://ideone.com/4cODb

tailgunner, о как.

Ну ладно, с прототипом еще можно понять, но ведь когда объявляется сама функция-то, то при ее объявлении ведь нужно перечислить аргументы, чтобы к ним можно было обращаться, так?

перечисляются, а типы указываются после скобок, если я правильно помню

Ясно.

Лана, всем спасибо.

В общем, ясно: это просто для обратной совместимости, использовать это нельзя.

А, нет, было вообще вот так:

int func() /*no parameters inside parentheses*/
int a,b; /*instead, parameters were declared here*/
float f; /*another  parameter*/
{
/*…function body*/
}

меня еще забавляет как разные компиляторы пережевывают повторное определение переменных, типа вот такое

int main() {
    for (int i;;) {
        // do smth
    }
    for (int i;;) {
        // do smth else
    }
}

va_list, va_arg, va_start

Там же надо писать в скобочках многоточие

Разве обязательно? Давно это было… может быть и так.

И вообще-то функция не может принимать только неименованные параметры. Должен быть как минимум один именованный для этого.

Может быть, «для совместимости со старыми» и сейчас не обязательно. Но лучше, все-таки, многоточие писать (чтобы было понятно, что это - функция с переменным числом аргументов, а не без аргументов).

А и правда.

вроде так жует только старый борланд

А в чем проблема? Две разных блока кода - разная область видимости.

ANSI C не позволяет так определять переменные, но в C99 - запросто.

В MS Visual C++ 6.0 одно определение в for-е объявляло переменную с областью видимости на всю функцию, второе, соответственно, вызывало ошибку. Что надо было курить, чтобы сделать такое поведение, я не знаю.

#include <stdio.h>
int main() {
    do { 
        int i = 0;          // start loop
        while (i < 4) {     // condition
                            // start body
            printf("%d\n", i);
                            // end body
            i++;            // next
        }
    } while (0);
    do {
        int i = 4;
        while (i > 0) {
            printf("%d\n", i);
            i--;
        }
    } while (0);
}

возможно создатели C99 думали про for таким образом

я вижу только возможность сделать ошибку.

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

Обычное поведение ранних компиляторов Си++, в которых и появилась возможность объявлять переменные в for.

А некоторые так вообще указатели забывают удалять. Или проверять. Давайте указатели тоже выпилим, ведь человек ошибку может совершить!

do {
} while (0);

facepalm.c

//hint:

{
}

я таких модных конструкций не разумею, ибо дрых на лекциях по сишке :3

еще интересно чем упарывались создатели перла (в плане аргументов функций), наверно из-за этого интерес к сему языку неуклонно падает

Такая конструкция кстати весьма популярна внутри define'ов, чтобы не сделать ошибку со скобками. Пример: http://stackoverflow.com/questions/154136/why-are-there-sometimes-meaningless-do-while-and-if-else-statements-in-c-c-macr

потому что в си первая конструкция равносильна

void test(...) {}

а в плюсах

void test(void) {}

а теперь зачем. потому что в сях в старинных было нормалным вызывать функцию нигде не определенную. тогда компилятор счетает что все аргументы - это аргументы типа int (или long?) т.е. это практически любая функция. поэтому можно было скомпилить код не имея .h и он каг-бе работал. ну и то же самое про кол-во аргументов...получается, любую функцию, ну скажем, malloc() можно было объявить так: void* malloc(); или же вообще не объявлять.

(man gcc => -Wmissing-prototypes)

в плюсах решили что это зло. исправили.

>еще интересно чем упарывались создатели перла (в плане аргументов функций), наверно из-за этого интерес к сему языку неуклонно падает

Возможностью вызывать функции с разным количеством аргументов.

> Разве обязательно?

Да. Пустой список параметров не гарантирует, что ты можешь передать любые параметры, а просто выключает проверку аргументов. Хочешь передать неизвестное кол-во - используй «…».

> потому что в си первая конструкция равносильна void test(...) {}

4.2

>> потому что в си первая конструкция равносильна void test(...) {}

4.2

А чему она на самом деле эквивалентна?

> тогда компилятор счетает что все аргументы - это аргументы типа int (или long?)

Тоже 4.2 Перепутал с типом возвращаемого значения.

> А чему она на самом деле эквивалентна?

Смотря где. В объявлении функции —

просто выключает проверку аргументов.

[C] void test() {} - По стантарту при вызове аргументы не проверяются. Почему? (комментарий)

В определении означает, что у функции аргументов нет (К.О.).

>> А чему она на самом деле эквивалентна?

Смотря где. В объявлении функции —— просто выключает проверку аргументов.

Так же, как и эллипсис. Я не понял, к чему именно ты придрался.

посмотри ассемблерный листинг от программы (не соберется, но скомпилится):

int myprintf();

int main() {
     myprintf("qwe %c %d %p\n", 'a', 123, main);
}

movl	$main, 12(%esp)
movl	$123, 8(%esp)
movl	$97, 4(%esp)
movl	$.LC0, (%esp)
call	myprintf

Я немного разобрался. еллипсис отличается от пустых скобок тем что типа компилятор при наличии ... может использовать специальный способ передачи аргументов. а пустые скобки - означает произвольное число аргументов передаваемых обычным путем. Так что это немного не эквивалент. Как показал тест GCC использует одинаковый метод вызова....

А ещё, при ... (ISO C requires a named argument before ‘...’), а при пустых скобках — не требуется..

Но по большому счёту, это риальне одно и то же. поэтому надо ввести бан за разбрасывание обвинений в 4.2

Для особо одарённых:

4.2:

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

Так вот именно ТЫ разводишь нездоровую дискуссию. так что это твоё сообщение про 4.2 является 4.2. Иименно ТЫ безаппеляционно сообщаешь вызывающе неверные факты о неэквивалентности и др.

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

movl	$main, 12(%esp)
...
movl	$.LC0, (%esp)

> Так же, как и эллипсис.

Ну, вообще да. С точки зрения компилятора, а не программиста, разумеется.

Я не понял, к чему именно ты придрался.

К тому, что в определении функции эти выражения не будут эквивалентны. (К.О., дубль 2)

> в определении функции эти выражения не будут эквивалентны. (К.О., дубль 2)

Капитан, объясните, в чем неэквивалентность «void f() {}» и «void f(...) {}».

Ну что же, ЛамерОк, расскажи-ка что же ты там увидал, а то все ходишь тут излучаешь лучи 4.2. а то пока кроме высера и копипаста я от тебя ничего не увидел. Ни ссылки на доки, ни объяснения твоей точки зрения.

> объясните

О_о

в чем неэквивалентность «void f() {}» и «void f(...) {}».

Можно, я просто процитирую стандарт?

6.9.1

8 If a function that accepts a variable number of arguments is defined without a parameter type list that ends with the ellipsis notation, the behavior is undefined.

Я чувствую под ногами мостик, а клавиши превращаются в ручки штурвала...

> Ни ссылки на доки, ни объяснения твоей точки зрения.

Малыш, запоминай урок 1-ый: бремя доказательства лежит на утверждающем. Видишь, tailgunner задаёт мне вопросы (о, боги!) по моему утверждению, и я на них отвечаю.

Ты выдвинул утвреждение:

тогда компилятор счетает что все аргументы - это аргументы типа int (или long?)

Ну так докажи его. Когда докажешь, тогда и поговорим.

> В MS Visual C++ 6.0 одно определение в for-е объявляло переменную с областью видимости на всю функцию, второе, соответственно, вызывало ошибку. Что надо было курить, чтобы сделать такое поведение, я не знаю.

Вообще-то такое поведение предложил господин Страуструп, но позже под давлением общественности оно было пересмотрено в пользу нынешнего.

с помощью такой конструкции работает open - как-то так: header

int open();

open.c:

int open(char *name, int mode, int perms)
{
    /* Blah, blah, blah... */
    if (mode & O_RW) {
        if (chmod(name, perms)) {
            /* Cleanup */
            return -1;
        }
    }
    return 0;
}

Естественно это не реальный код, но смысл ясен :).