Указатели typedef - это хорошая идея?

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

По сути, если ваш код никогда не разыменовывает указатель, и вы просто передаете его функциям API (иногда по ссылке), тогда typedef не только уменьшает количество *s в вашем коде, но также предлагает программисту, что указатель действительно не должен вмешиваться.

Это также упрощает изменение API в будущем, если возникнет такая необходимость. Например, если вы перейдете на использование идентификатора, а не указателя (или наоборот), существующий код не сломается, потому что указатель никогда не должен был быть разыменован в первую очередь.

Не по моему опыту. Скрытие "*" затрудняет чтение кода.

Единственный раз, когда я использую указатель внутри typedef, - это когда имею дело с указателями на функции:

typedef void (*SigCatcher(int, void (*)(int)))(int);

typedef void (*SigCatcher)(int);

SigCatcher old = signal(SIGINT, SIG_IGN);

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

 typedef SigCatcher (*SignalFunction)(int, SigCatcher);

 extern SigCatcher signal(int, SigCatcher);

То есть SignalFunction - это указатель на функцию, которая принимает два аргумента (int и SigCatcher) и возвращает SigCatcher. А сама signal() является функцией, которая принимает два аргумента (int и SigCatcher) и возвращает SigCatcher.

Это может помочь вам избежать некоторых ошибок. Например, в следующем коде:

int* pointer1, pointer2;

Указатель2 не является int *, это просто int. Но с typedef этого не произойдет:

typedef int* pInt;
pInt pointer1, pointer2;

Теперь они оба int *.

Мой ответ - однозначное «Нет».

Почему?

Во-первых, вы просто меняете один символ * на другой отдельный символ p. Это нулевой прирост. Одно это должно удерживать вас от этого, потому что делать лишние бессмысленные вещи всегда плохо.

Во-вторых, и это важная причина, * несет значение, которое не следует скрывать. Если я передам что-то такой функции

void foo(SomeType bar);

void baz() {
    SomeType myBar = getSomeType();
    foo(myBar);
}

Я не ожидаю, что значение myBar изменится, если передать его foo(). В конце концов, я передаю по значению, так что foo() когда-либо видит только копию myBar, верно? Не тогда, когда псевдоним SomeType означает какой-то указатель!

Это применимо как к указателям C, так и к интеллектуальным указателям C ++: если вы скроете тот факт, что они являются указателями для ваших пользователей, вы создадите беспорядок, в котором нет необходимости. Поэтому, пожалуйста, не используйте псевдонимы для своих указателей.

(Я считаю, что привычка определять типы указателей - это просто ошибочная попытка скрыть, сколько звездочек у человека, как у программиста http://wiki.c2.com/?ThreeStarProgrammer.)

Это вопрос стиля. Вы очень часто видите такой код в заголовочных файлах Windows. Хотя они, как правило, предпочитают версию в верхнем регистре вместо строчной буквы p.

Лично я избегаю этого использования typedef. Намного понятнее, если пользователь явно скажет, что ему нужен Foo *, чем PFoo. Typedef в наши дни лучше всего подходят для чтения в STL :)

typedef stl::map<stl::wstring,CAdapt<CComPtr<IFoo>> NameToFooMap;

Это (как и многие ответы) зависит.

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

MYDB   db = MYDBcreateDB("Plop://djdjdjjdjd");

MYDBDoSomthingWithDB(db,5,6,7);
CallLocalFuc(db); // if db is not a pointer things could be complicated.
MYDBdestroyDB(db);

Под MYDB, вероятно, находится указатель на какой-то объект.

В C ++ это больше не требуется.
В основном потому, что мы можем передавать информацию по ссылке, а методы включены в объявление класса.

MyDB   db("Plop://djdjdjjdjd");

db.DoSomthingWithDB(5,6,7);
CallLocalFuc(db);   // This time we can call be reference.
db.destroyDB();     // Or let the destructor handle it.

No.

Это сделает вашу жизнь несчастной, как только вы смешаете ее с const

typedef foo *fooptr;
const fooptr bar1;
const foo *bar2

bar1 и bar2 одного типа?

И да, я просто цитирую Гуру Херба Саттера. Она говорила много правды. ;)

-- Редактировать --

Добавление ссылки на цитируемую статью.

http://www.drdobbs.com/conversationsa-midsummer-nights-madness/184403835

Typedef используется, чтобы сделать код более читаемым, но использование указателя в качестве typedef вызовет путаницу. Лучше избегать указателей typedef.

^{Обсуждение проводится при условии, что интересующий язык - C. Разветвления для C ++ не рассматривались.}

Использование typedef указателя для немаркированной структуры

Вопрос Размер структуры, которая определяется как указатель, поднимает интересный побочный свет при использовании typedef для указателей (структуры).

Рассмотрим определение бетонного (непрозрачного) типа структуры без тегов:

typedef struct { int field1; double field2; } *Information;

Детали участников совершенно не касаются этого обсуждения; все, что имеет значение, это то, что это не непрозрачный тип, такой как typedef struct tag *tag; (и вы не можете определить такие непрозрачные типы с помощью typedef без тега).

Возникает вопрос: «Как узнать размер этой структуры»?

Краткий ответ: «только через переменную типа». Нет тега для использования с sizeof(struct tag). Вы не можете использовать, например, sizeof(*Information), а sizeof(Information *) - это размер указателя на тип указателя, а не размер типа структуры.

Фактически, если вы хотите выделить такую ​​структуру, вы не можете создать ее, кроме как с помощью динамического распределения (или суррогатных методов, имитирующих динамическое распределение). Невозможно создать локальную переменную типа структуры, указатели которой называются Information, также нет способа создать переменную области видимости файла (глобальную или static) типа структуры, а также нет способа встроить такую ​​структуру (в отличие от указателя на такую ​​структуру) в другую структуру или тип объединения.

Вы можете - должны - написать:

Information info = malloc(sizeof(*info));

Помимо того, что указатель скрыт в typedef, это хорошая практика - если тип info изменится, распределение размера останется точным. Но в этом случае это также единственный способ получить размер структуры и выделить структуру. И нет другого способа создать экземпляр структуры.

Это вредно?

Это зависит от ваших целей.

Это не непрозрачный тип - детали структуры должны быть определены, когда тип указателя typedef'd.

Это тип, который можно использовать только с динамическим распределением памяти.

Это безымянный тип. Указатель на тип структуры имеет имя, а сам тип структуры - нет.

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

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

Резюме

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

Если вы сделаете это, вы не сможете создавать STL-контейнеры const pSomeStruct, поскольку компилятор читает:

list<const pSomeStruct> structs;

as

list<SomeStruct * const> structs;

который не является легальным контейнером STL, поскольку элементы не могут быть присвоены.

См. Этот вопрос.

Win32 API делает это практически с каждой структурой (если не со всеми).

POINT => *LPPOINT
WNDCLASSEX => *LPWNDCLASSEX
RECT => *LPRECT
PRINT_INFO_2 => *LPPRINT_INFO_2

Приятно, что это единообразно, но, на мой взгляд, элегантности это не добавляет.

Цель typedef - скрыть детали реализации, но определение типа свойства указателя скрывает слишком многое и затрудняет чтение / понимание кода. Так что, пожалуйста, не делай этого.

Если вы хотите скрыть детали реализации (что часто бывает полезно), не скрывайте часть указателя. Возьмем, к примеру, прототип стандартного FILE интерфейса:

FILE *fopen(const char *filename, const char *mode);
char *fgets(char *s, int size, FILE *stream);

здесь fopen возвращает указатель на некоторую структуру FILE (детали реализации которой вы не знаете). Возможно, FILE не такой уж хороший пример, потому что в этом случае он мог работать с каким-то типом pFILE, который скрывал тот факт, что это указатель.

pFILE fopen(const char *filename, const char *mode);
char *fgets(char *s, int size, pFILE stream);

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

Некоторое время назад я бы ответил «нет» на этот вопрос. Теперь, с появлением интеллектуальных указателей, указатели больше не всегда обозначаются звездочкой '*'. Таким образом, нет ничего очевидного в том, является ли тип указателем или нет.

Итак, теперь я бы сказал: указатели typedef - это нормально, если четко указано, что это «тип указателя». Это означает, что вы должны использовать префикс / суффикс специально для этого. Нет, например, «p» не является достаточным префиксом. Я бы, наверное, выбрал "ptr".