[C++] почему?

>про f((int[3]){1, 2, 3})

тут тип известен. хотя насколько это соответствует стандарту, судить не берусь.

>>Взять адрес у несуществующего массива реально трудно.

> Он вполне себе существует в рантайме в секции .const вместе с другими литералами.

Нет гарантии существования литерных констант в рантайме.

int a;
a = a + 1;

"1" - литерная константа, но ни в сеции .const, ни где бы то нибыло еще ее может не оказаться. Достаточно очевидно, что взять адрес у литерной константы на этапе компиляции нельзя, и добавленный воркэраунд для "string literal" не отменяет этого общего правила.

> int a;
> a = a + 1;

Подразумевается

int a;
...
a = a + 1;

>добавленный воркэраунд для "string literal" не отменяет этого общего правила

чем этот воркэраунд не подходит для общего случая?

>добавленный воркэраунд для "string literal" не отменяет этого общего правила.

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

Вопросы к Д. Ритчи.

>Вопросы к Д. Ритчи.

ну вот, чуть что так сразу к Ритчи; неужели на ЛОРе не хватит аналитиков, чтобы ответить на этот вопрос?

С того, что этот синтаксис ортогонален синтаксису любых других константных литералов во время компиляиции и введен с единственной целью - не превращать объявление обычных строк в священную процедуру с бубуном. И, сделав это исключение, всё таки напоролись на грабли с const, приведенные выше.

>не превращать объявление обычных строк в священную процедуру с бубуном

несправедливость же - для всех остальных составных литералов бубен остался

ко второму вопросу

void g(const char a[3])
{
    std::cout << "sizeof a = " << sizeof(a) << "\n";
    std::cout << "strlen(a) = " << strlen(a) << std::endl;
}

...

g("123456");

sizeof a = 4
strlen(a) = 6

и у нас как бы функция типа void (const char[3]), которая на самом деле получает ни разу не const char[3]. -Wall -pedantic, ни одного предупреждения

>И, сделав это исключение, всё таки напоролись на грабли с const, приведенные выше.

какие грабли из-за строковых литералов тебе померещились?

>С того, что этот синтаксис ортогонален синтаксису любых других константных литералов во время компиляиции

это что-то не бред больше похоже.

> и у нас как бы функция типа void (const char[3]), которая на самом деле получает ни разу не const char[3].

Может ты наконец поймешь разницу между указателем и массивом?

> void f(const int[3]);

void f(int[const 3]);

в С99 такая запись.

>и у нас как бы функция типа void (const char[3]), которая на самом деле получает ни разу не const char[3]. -Wall -pedantic, ни одного предупреждения

и что тебе удивило? что есть размер указателя? что же ещё можно ожидать от фаната с мозгами промытыми микрософт хаскел(тм).

> какие грабли из-за строковых литералов тебе померещились?

Тебе не понятна разница междуо объявлениями
char *t;
и
const char *t;

?

> это что-то не бред больше похоже.

Хороший способ сказать "я не понял ответа" )))

>Может ты наконец поймешь разницу между указателем и массивом?

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

>и что тебе удивило? что есть размер указателя?

отсутствие предупреждений во время компиляции. преобразование константного массива к указателю - не проблема, а вот обратное (с заменой размерности) уже, мягко говоря, чревато проблемами

>Тебе не понятна разница междуо объявлениями

Строковые литералы являются константами.

Блджад, не тупи. Тип char[] идентичен типу char* Это разная запись одной и той же семантической конструкции.

С какого года? Грабли, о которых я говорил, - необходимость менять тип указателя, котороый можно инициализировать стринговой литерной константой.

> Тип char[] идентичен типу char*

Ламер ты и есть. Злокачественный.

>void g(const char a[3])

>и у нас как бы функция типа void (const char[3]), которая на самом деле получает ни разу не const char[3].

ты не можешь передать в функцию массив. http://www.cplusplus.com/doc/tutorial/pointers/.

>преобразование константного массива к указателю - не проблема, а вот обратное (с заменой размерности) уже, мягко говоря, чревато проблемами

we’re still screwing around with ’70s debuggers and linkers, and it’s stupid. I don’t know why we put up with it. (C) Brendan Eich

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

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

>Тип char[] идентичен типу char* Это разная запись одной и той же семантической конструкции.

Нифига- char[] - массив, char* - указатель. Ничего общего, разве что а) У параметров функций - массивов срезается первая размерность и замещается указателем и б) при передаче массива в функцию делается автокаст массив->указатель.

> Тип char[] идентичен типу char*

рукалицо.жпг

не совсем - http://c-faq.com/decl/strlitinit.html

> Нифига- char[] - массив, char* - указатель. Ничего общего, разве что
... б) при передаче массива в функцию делается автокаст массив->указатель.

Это и имеется в виду. А не то, о чём вы все подумали, грязные извращенцы.

> что-то вроде того,

Что то вроде того, что синтаксис языка _ПРИШЛОСЬ МЕНЯТЬ_, блджад.

ты не можешь передать в функцию массив

template <typename T, size_t n>
size_t size(T (&)[n])
{
	return n;
}

у меня этот пример скоро уже в печёнках будет

Тип char[] идентичен типу char* Это разная запись одной и той же семантической конструкции.

все милостиво над тобой поулыбались

теперь к сути вопроса:

void f(const int a[3])
{
	std::cout << "f. sizeof a = " << sizeof(a) << std::endl;
}

void g()
{
	const int a[3] = {1, 2, 3};

	std::cout << "g. sizeof a = " << sizeof(a) << std::endl;

	f(a);
}

результат где-то такой:

g. sizeof a = 12
f. sizeof a = 4

в функции g есть локальная переменная типа int[3], в функции f есть локальная переменная типа int[3]. тип одинаковый, результат выполнения sizeof - разный. преобразование было произведено подкапотно, без лексически наблюдаемого описания, без предупреждения

> все милостиво над тобой поулыбались

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

> в функции g есть локальная переменная типа int[3], в функции f есть локальная переменная типа int[3].

её так и не понял.

>разницу между типом переменной и типом выражения

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

template<size_t size>
void ft(const int (&)[size]);

template<>
void ft(const int (&)[3])
{
	std::cout << "ft. sizeof a = 3, fixed" << std::endl;
}

такой вариант работает, но падает совсем не так хорошо, как хотелось бы

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

Чего ж тут непонятного? Ты видишь здесь объявление массива?

void f(const int a[3])
{
   std::cout << "f. sizeof a = " << sizeof(a) << std::endl;
}

const int a[3]

Локальная переменная-массив.

>Ты видишь здесь объявление массива?

const int a[3]. локальная переменная функции f, имеет имя a и тип int[3]

>в функции f есть локальная переменная типа int[3]. тип одинаковый, результат выполнения sizeof - разный.

гы-гы. а ничего, что sizeof в рантайме, где уже в сях нету никаких типов.

а ничего, что sizeof в рантайме

тебя ждёт много удивительных открытий. sizeof - compile-time операция

template <size_t n>
int test()
{
	return n;
}

...

test<sizeof(char)>();

компилируется и работает на ура

>template <typename T, size_t n>
size_t size(T (&)[n])
{
return n;
}

И что? Ты не передашь массив в функцию. Ты как вообще догадался объявлять функцию как f(some_type[amount]) ?

>sizeof - compile-time операция

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

И что? Ты не передашь массив в функцию.

*икнул* а что же я делаю?

template <typename T, size_t n>
void print(T (&a)[n])
{
	for(int i = 0; i < n; ++i)
	{
		std::cout << "a[" << i << "] = " << a[i] << std::endl;
	}
}

вроде передаётся

Ты как вообще догадался объявлять функцию как f(some_type[amount]) ?

потребовалось для подсчёта количества элементов сишного массива. sizeof(arr)/sizeof(elem) в таком случае не работает - благодаря всё тому же неявному преобразованию к типу указателя

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

это что за поток сознания? не распарсил

template <bool> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true> {};

template<size_t size>
void ft(const int (&)[size])
{
	STATIC_ASSERTION_FAILURE<false>();
}

template<>
void ft(const int (&)[3])
{
	std::cout << "ft. sizeof a = 3, fixed" << std::endl;
}

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

> const int a[3]. локальная переменная функции f, имеет имя a и тип int[3]

Ты не увиливай, а отвечай на прямо поставленный вопрос - здесь есть объявление массива или нет?

>это что за поток сознания?

так и запишем: автор не осилил, но осуждает.

>а вот такой вариант, наконец-то, падает в компайл-тайм.

Это фейл. Функция ft должна быть в .c++ файле и оно должно падать в линк-тайм.

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

>Это фейл

почему?

>Функция ft должна быть в .c++ файле и оно должно падать в линк-тайм.

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