Как грамотно нтерпретировать ввод нового имени типа, введённого typedef

Друзья! Дело в том, что вот такой вот код:
И он значит, что

char6 есть указатель на строку из шести символов.

Это я прочёл в учебнике, то бишь вызубрил, но чуть более сложную конструкцию я сам разобрать не могу. Хотелось бы какой-то общий алгорим прочесть подобно тому, как разбирать сложные объявления функций; благодаря последнему я сам могу кропать "указатель на функцию, возвpащающую указатель на массив из тpёх указателей на функции, возвpащающие значение int"

(Во вложении показано, что я имею ввиду)

Здесь же непонятно как разбирать,интуитивно могу предполагать только, то символам * () [] отводится особая роль, но какая именно сам понять не могу, спасибо кто подскажет.

Вложения

slozh_ob.txt (3.3 Кб, 35 просмотров)

0

kravam, чем не устроил ответ в 16 посте?

Добавлено через 1 минуту

0

Нет. Это вы исходите из того, раз компилится, значит есть в этом какой-то смысл. А смысла нет.
По крайней мере, если есть какая-то переменная некоторого типа, то она характеризуется точным размером.

Какой размер может быть у переменной типа "функция, возвращающей char*, параметры отсутсвуют."?
(Не указатель на функцию, а именно функция (пусть даже и без имени, раз мы его опускаем))
Переменная вышеупомянутого так называемого типа не обладает никаким размером.(если не считать размером длину кода, хе). Значит, это не тип, а непонятно что.

То есть не всё золото, что блестит. Не всё, что компилится, имеет смысл.

0

Сообщение от kravam То есть не всё золото, что блестит. Не всё, что компилится, имеет смысл.

А это я вам сказал ещё в посте 14.

Сообщение от kravam По крайней мере, если есть какая-то переменная некоторого типа, то она характеризуется точным размером.

Переменная - да. Тип - нет. Тип - это шаблон, по которому строится структура переменной в памяти. typedef не работает с переменными, он работает с типами.

Сообщение от kravam Какой размер может быть у переменной типа "функция, возвращающей char*, параметры отсутсвуют."?

Никакого, потому что функция - не переменная. Опять же - мы говорим о типах, всего лишь о типах.

Сообщение от kravam Переменная вышеупомянутого так называемого типа не обладает никаким размером.(если не считать размером длину кода, хе). Значит, это не тип, а непонятно что.

И ещё раз - это не переменная. Имя функции - не переменная. У переменной и имени функции общее только одно: и то, и другое - идентификаторы.

1

Так-то прикольно.

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

0

Хм...

Тип есть. Переменных нет (пока мы их не создадим). Не?

0

Не. Нужно видеть разницу между похожими вещами.
Ваш пример предполагает, что можно корректно создать переменные a и b. И даже получитьт их адреса и посмотреть в отладчике на эти адреса. Увидеть переменные! Сами же сказали "пока не создадим".

Я же говорю о случае, когда переменую типа такого-то(см. выше) создать невозможно в принципе. Ситуации похожие, но разные.

0

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

0

Я хочу, чтобы вы согласились, да, эта штука компилиться не должна, как не должна вода быть сухой, а воздух твёрдым
typedef char(*g());

0

kravam, нет, не соглашусь. Должна. И в 16 посте показано, как это можно использовать. Не понимаю, чего вам не нравится. Почему вы тип связываете с размером? Да, функция не имеет размер (в общем смысле), но зато она вернёт значение, которое будет иметь соответствующий этому типу размер. Как и любая другая функция. Только о других (объявленных стандартным способом) вы почему-то никаких недовольств не выказали.

0

Сообщение от kravam Я хочу, чтобы вы согласились, да, эта штука компилиться не должна, как не должна вода быть сухой, а воздух твёрдым typedef char(*g());

Ты не прав. Эта штука компилиться будет, потому что она объявляет ТИП. Если имеется тип, то вовсе не обязательно, что можно создать переменную такого типа, но в обязательном порядке можно создавать переменную, являющуюся указателем на данный тип. За примером ходить далеко не надо - это обычный void. Переменную типа void создать нельзя, но переменную типа указатель на void - можно. Точно так же и с типом, который является функцией (но не указателем на функцию). Пример смотри тут: https://www.cyberforum.ru/cpp/... ost1553517

Добавлено через 9 минут
Или вот такой тип: "typedef int arr_t[];". В стандартном Си ты НЕ можешь объявить переменную такого типа, но можешь объявить указатель или описать внешнюю переменную (пишу именно про стандартный Си, потому что в GNU C это можно сделать). Т.е. опять имеем тип, но не имеем права создать переменную данного типа

1

Хорошо. Пусть бывает собственно тип переменной, а пусть бывает тип не знаю даже как назвать. Моих мозгов хватает на то, что после "тип" должно идти существительное в родительном падеже. Тип человека, тип функции, тип переменной. Это ладно.

Но вернёмся к истокам. Другой вопрос. Как интерпретировать сложные объявления?:

Вы сказали, как. Но тут одна загвоздка. Дабы применить к подобным сложным выражениям правила интерпретации, надо сперва осознать, что они сложные. А чтобы осознать, что они сложные, их надо интерпретировать, а чтобы их интерпретировать, надо осознать, что они сложные...
+++++++++++++++++++
Или какое-то двойное правило?:

Интерпретируем так: отбрасываем typedef, оставляем(!) имя и всё, что левее и говорим: имя есть синоним типа "называем что левее имени"

ОК, а этот пример интерпретируем по вашим правилам.
Добро коли так. Дело за малым. Осталось формализировать различия. То есть чётко сказать: сложное объявление это такое, где есть то-то то-то и то-то в таком-то то количестве (я имею ввиду скобки, звёздочки ну и прочая.)

А простое... Это другое какое-то.

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

(На всякий случай: интерпретация сложных объявлений, что я в приложении дал действительно формализовано и как бы стандартизировано. Сколь угодно сложные (ЛЮБЫЕ!) обявления можно с успехом интерпретировать по приведённым правилам.)

0

Сообщение от kravam (На всякий случай: интерпретация сложных объявлений, что я в приложении дал действительно формализовано и как бы стандартизировано. Сколь угодно сложные (ЛЮБЫЕ!) обявления можно с успехом интерпретировать по приведённым правилам.)

А вот теперь перечитайте эту строку и делайте это до полного просветления.

0

Не, ситуации разные.
Даёт нам право char заменять char_-ом

Не имеем права X заменять Y-ом. И где та степень сложности, при которой начинается "не имеем права X заменять Y-ом" я не знаю.

Добавлено через 50 секунд
Кстати, где X и Y я тоже не знаю, но это ладно, потом разберусь

Добавлено через 36 секунд
А в первом примере всё ясно, X это char, Y это char_

0

Да нет степеней сложности. Компилятор оба выражения по одному алгоритму интерпретирует. Просто в первом случае алгоритм заканчивается, только начавшись. А во втором типу char *() ставится в соответствие псевдоним g.

Добавлено через 48 секунд
X - char *() (функция без параметров, возвращающая указатель на char), Y - g.

1

Ну так-то понятно. Получается, все переопределения типов надо интерпретиовать по правилам введённым Evg, не ошибёмся. Но он там написал:

Точно так же откидываешь typedef и g и получается "char (*())". Самые внешние скобки можно отбросить (как и п остие #18) и получится "char *()". Т.е. тип функции, возвращающей char*, параметры отсутсвуют. Чтобы лишний пробел не смущал, то переписать это как "char* ()". Но не путать с указателем на функцию, потому как у указателя на функцию скобки вокруг звёздочки ставятся.

typedef-то надо отбрасывать, а g не надо; последнее должно учавствовать в конечном словесном определении. Это понятно.

++++++++++++++++++++++++++++++++++++++++ +++++++++++++++

Возник вопрос. Почему в таком случае сие не компилится?
Но он риторический, скорее. ВЫ же не обязаны знать, почему компилятор не компилят. Хотя вроде должен. Слева-тип (функция, возвращающей char*, параметры отсутсвуют.). Справа- типозаменитель g. Но не компилит.

Ну и что касается самих типов (не интерпретации!) я ещё подумаю.

0

Сообщение от kravam Почему в таком случае сие не компилится?

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

0

Сообщение от kravam Но вернёмся к истокам. Другой вопрос. Как интерпретировать сложные объявления?: C++ 1 typedef char(*g()); Вы сказали, как. Но тут одна загвоздка. Дабы применить к подобным сложным выражениям правила интерпретации, надо сперва осознать, что они сложные. А чтобы осознать, что они сложные, их надо интерпретировать, а чтобы их интерпретировать, надо осознать, что они сложные... +++++++++++++++++++ Или какое-то двойное правило?: C 1 typedef char char_; Интерпретируем так: отбрасываем typedef, оставляем(!) имя и всё, что левее и говорим: имя есть синоним типа "называем что левее имени"

Делаем ровно так же. Отбрасываем typedef и отбрасываем идентификатор char_. То что осталось - это char - эквивалент нового типа. Хоть "простой", хоть "сложный" случай интерпретируются одинаково

Сообщение от kravam Почему в таком случае сие не компилится? C 1 typedef char(*()) g;

Примерно потому же, почему "char* func ()" компилится, а "char* () func" - нет

1

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

не иначе

Добавлено через 9 минут

Сообщение от Evg То что осталось - это char - эквивалент нового типа.

чё-то не то

0

Сообщение от kravam чё-то не то

Что именно не то? Или я не так сформулировал. То, что осталось - это то, чему равен новый тип (ровно так же, как и в "сложном" случае)

0