Указатель на структуру - что напечатает программа

в данном случае struct MyStruct* p и MyStruct* p - это будут разные вещи.
struct MyStruct* p - объявление указателя на неизвестную структуру. При попытке компиляции будет ошибка, т.к. размер этой структуры неизвестен.
вот такие у меня пока догадки

В языке Си допустима конструкция типа:

Эта конструкция не определяет никаких материальных сущностей, но описывает функцию. Точно так же можно предописывать структуру:

Такая конструкция не заводит нового типа, но заводит новое имя типа. Т.е. мы говорим, что есть такая структура struct s, но её потроха мы пока не описываем. Переменную такого типа создавать нельзя, потому что для определения переменной нужно знать её размер, а размера мы не знаем, потому что внутренности типа ещё не описали. Но мы уже можем создавать указатели такого типа:

Указатель - это переменная, которая хранит внутри себя адрес. И не важно, какого размера является объект, на который смотрит этот адрес, сам адрес всегда занимает один и тот же размер (4 байта на 32-битных архитектура). Таким образом, не описывая внутренностей структуры уже можно создать указатель на такую структуру (или typedef на указатель). С такими указателями даже можно работать: присваивать указатели или сравнивать их между собой. Потому что эти операции не требуют знания о размере типа, на который смотрит указатель. Но вот операции поинтерной арифметики уже требуют знания о размере структуры, поэтому работать не буду (компилятор выдаст ошибку о работе с незавершённым типом). А операции дереференса (или работы с полями) требуют наличия внутренностей структуры. Они точно так же не будут работать, хотя природа этого запрета получается немного другая.

Вторая часть вопроса - это объявление "struct MyStruct" и "typedef MyStruct". Как уже говорилось, с точки зрения языка две данные конструкции различны:

Первая конструкция определяет тип, имя которого как бы "struct MyStruct", а вторая конструкция определяет неименованную структуру и typedef на неё под именем "MyStruct". С точки зрения языка Си - это два совершенно разных типа. Несколько иная картина в Си++. Первая конструкция как бы задаёт сразу два имени: "struct MyStruct" и "MyStruct". И обращаться к такой структуре можно либо как "struct MyStruct", либо как "MyStruct". На этом свойстве основан первый пример из поста https://www.cyberforum.ru/cpp-... post889587 - будучи скормленным компилятору Си и Си++ он выдаст разные результаты.

Итого, ответы на вопросы будут такие:

> 1. Что напечатается?
0, null - не суть. Важно то, что конструкция корректная и каким-то образом отработает печать null-pointer'а

> 2. Что будет, если раскомментировать закомментированный код?
Пример не скомпилируется, потому что арифметика над незавершённым типом запрещена

> 3. Что будет, если данный тест подать в компилятор Си++?
Пример не скомпилируется, потому что конструкция struct MyStruct не сможет отработать из-за того, что будет конфликт по именам с первым typedef'ом.

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

Для чего используются незавершённые типы? В первую очередь для того, чтобы описать некий указатель, причём не абы какой, а с конкретным именем, но чтобы при этом не дать пользователю работать с внутренностями данного указателя. Так называемый, транзитный указатель. Такой природой обладает тип FILE* на Си или HANDLE под windows. И тот и другой тип используется просто как некая именованная конструкция, но при этом пользователь может её только создать, удалить, скопировать, куда-то передать и т.п. Техническая реализация может быть и такая, что пользователю физически доступны потроха, но концептуальная природа такова, что пользователь этими типами пользуется только транзитно, не заглядывая вовнутрь. При этом делается дополнительная страховка в виде того, что, к примеру, в процедуру, ожидающую FILE*, нельзя подсовывать int*. Т.е. задав имя, мы задаём новый тип, который несовместим с прочими типами