Когда я должен использовать определение типа в C++?

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

На машине, где sizeof(int) 4, Вы можете

typedef int int32;

Затем использование int32 везде в Вашем коде. Когда Вы перемещаетесь в реализацию C++, где sizeof(int) 2, затем можно просто измениться typdef

typedef long int32;

, и программа будет все еще работать над новой реализацией.

используйте с указателем функции

, Скрывают Объявления Указателя функции С определением типа

void (*p[10]) (void (*)() );

, Только немного программистов могут сказать, что p является "массивом 10 указателей на возврат функции пусто и взятие указателя на другую функцию, которая возвращается пусто и не берет аргументов". Громоздкий синтаксис почти непонятен. Однако можно значительно упростить его при помощи объявлений определения типа. Во-первых, объявите определение типа для "указателя на возврат функции пусто и взятие никаких аргументов" следующим образом:

  typedef void (*pfv)();

Затем, объявляют другое определение типа для "указателя на возврат функции пусто и взятие pfv" на основе определения типа, которое мы ранее объявили:

 typedef void (*pf_taking_pfv) (pfv);

Теперь, когда мы создали pf_taking_pfv определение типа, поскольку синоним для громоздкого "указателя на возврат функции пусто и взятие pfv", объявляя массив 10 таких указателей является бризом:

  pf_taking_pfv p[10];

от

Только обеспечить некоторые примеры для сказанных вещей: контейнеры STL.

 typedef std::map<int,Froboz> tFrobozMap;
 tFrobozMap frobozzes; 
 ...
 for(tFrobozMap::iterator it=frobozzes.begin(); it!=map.end(); ++it)
 {
     ...
 }

весьма обычно даже использовать определения типов как [1 110]

typedef tFrobozMap::iterator tFrobozMapIter;
typedef tFrobozMap::const_iterator tFrobozMapCIter;

Другой пример: использование общих указателей:

class Froboz;
typedef boost::shared_ptr<Froboz> FrobozPtr;

[обновление] Согласно комментарию - куда поместить их?

последний пример - использование shared_ptr - легок: истинный материал заголовка - или по крайней мере вперед заголовок. Вам действительно нужно предописание для shared_ptr так или иначе, и одно из его заявленных преимуществ - то, что безопасно использовать с вперед decl.

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

(Да, xyzfwd.h является болью. Я использовал бы их только в горячих точках - знающий, что горячие точки трудно определить. Обвините C++ compile+link модель...)

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

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

// FrobozMangler.h
#include "Froboz.h"
typedef std::map<int, Froboz> tFrobozMap;
void Mangle(tFrobozMap const & frobozzes); 

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

• объявляют это вместе с содержавшим типом (подходящий для контейнеров, которые часто используются для этого типа)
• , перемещают их в отдельный заголовок
• перемещение к отдельному заголовку и делают это классом данных, где фактический контейнер является деталью реализации снова

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

определение типа полезно в большом количестве ситуаций.

В основном это позволяет Вам создавать псевдоним для типа. Когда/если необходимо изменить тип, остальная часть кода могла быть неизменной (это зависит от кода, конечно). Например, скажем, Вы хотите к проходу на векторе C++

vector<int> v;

...

for(vector<int>::const_iterator i = v->begin(); i != v.end(); i++) {

// Stuff here

}

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

typedef vector<int> my_vect;

my_vect v;

...

for(my_vect::const_iterator i = v->begin(); i != v.end(); i++) {

// Stuff here

}

Теперь просто необходимо изменить одну строку кода (т.е. от" typedef vector<int> my_vect" к" typedef list<int> my_vect"), и все работает.

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

Одно серьезное основание использовать определение типа состоит в том, если тип чего-то может измениться. Например, скажем, это на данный момент, 16-разрядные ints хорошо для индексации некоторого набора данных, потому что для обозримого будущего, у Вас будет меньше чем 65 535 объектов, и что пространственные ограничения являются значительными, или Вам нужна хорошая производительность кэша. Однако на всякий случай то, что необходимо использовать программу на наборе данных больше чем с 65 535 объектами, Вы хотите смочь легко переключиться на более широкое целое число. Используйте определение типа, и только необходимо изменить это в одном месте.

Реальное использование определения типа:

• обеспечивающие дружественные псевдонимы для многоречивых шаблонных типов
• обеспечивающие дружественные псевдонимы для типов указателя функции

• обеспечивающие локальные маркировки для типов, например:

  template<class _T> class A
  {
      typedef _T T;
  };
  
  template<class _T> class B
  {
      void doStuff( _T::T _value );
  };
  

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

я использую вид определения типа в C# для дженериков/шаблонов. "NodeMapping" просто лучше, чтобы читать/использовать и понять затем много "Dictionary< строка, XmlNode>";. по моему скромному мнению. Таким образом, я рекомендовал бы это для шаблонов.

... и Вам не нужно Определение типа для перечисления или структуры.

Или делают Вас?

typedef enum { c1, c2 } tMyEnum;
typedef struct { int i; double d; } tMyStruct;

может быть лучше записан, как

enum tMyEnum { c1, c2 }
struct  tMyStruct { int i; double d; };

, это исправляет? Что относительно C?