Até onde ir com tipos primitivos digitados como int

Eu vi código C ++ como o seguinte com muitos typedefs.

Quais são os benefícios de usar muitos typedefs como este, em vez de usar primitivas C ++? Existe outra abordagem que também possa alcançar esses benefícios?

No final, todos os dados são armazenados na memória ou transmitidos pelo fio como bits e bytes, isso realmente importa?

types.h:

typedef int16_t Version;
typedef int32_t PacketLength;
typedef int32_t Identity;
typedef int32_t CabinetNumber;
typedef int64_t Time64;
typedef int64_t RFID;
typedef int64_t NetworkAddress;
typedef int64_t PathfinderAddress;
typedef int16_t PathfinderPan;
typedef int16_t PathfinderChannel;
typedef int64_t HandsetSerialNumber;
typedef int16_t PinNumber;
typedef int16_t LoggingInterval;
typedef int16_t DelayMinutes;
typedef int16_t ReminderDelayMinutes;
typedef int16_t EscalationDelayMinutes;
typedef float CalibrationOffset;
typedef float AnalogValue;
typedef int8_t PathfinderEtrx;
typedef int8_t DampingFactor;
typedef int8_t RankNumber;
typedef int8_t SlavePort;
typedef int8_t EventLevel;
typedef int8_t Percent;
typedef int8_t SensorNumber;
typedef int8_t RoleCode;
typedef int8_t Hour;
typedef int8_t Minute;
typedef int8_t Second;
typedef int8_t Day;
typedef int8_t Month;
typedef int16_t Year;
typedef int8_t EscalationLevel;

Parece lógico tentar garantir que o mesmo tipo seja sempre usado para uma coisa específica, a fim de evitar estouros, mas geralmente vejo código em que "int" foi usado praticamente em todo lugar. O typedefing geralmente leva a um código que se parece um pouco com isso:

DoSomething(EscalationLevel escalationLevel) {
    ...
}

O que me faz pensar em qual token está realmente descrevendo o parâmetro: o tipo ou o nome do parâmetro?

O nome de um parâmetro deve descrever o que isso significa - no seu caso, o nível de escalação. O tipo é como o valor é representado - adicionar typedefs, como no seu exemplo, ofusca essa parte da assinatura da função, então eu não o recomendaria.

Typedefs são úteis para modelos, ou se você deseja alterar o tipo usado para determinados parâmetros, por exemplo, ao migrar de uma plataforma de 32 bits para uma de 64 bits.

No começo, pensei "Por que não", mas me ocorreu que, se você se esforçar tanto para separar os tipos assim, use melhor o idioma. Em vez de usar aliases, defina realmente os tipos:

class AnalogueValue
{
public:
    // constructors, setters, getters, etc..
private:
    float m_value;
};

Não há diferença de desempenho entre:

typedef float AnalogueValue;
AnalogValue a = 3.0f;
CallSomeFunction (a);

e:

AnalogValue a (3.0f); // class version
CallSomeFunction (a);

e você também tem as vantagens de adicionar validação de parâmetro e segurança de tipo. Por exemplo, considere o código que lida com dinheiro usando tipos primitivos:

float amount = 10.00;
CallSomeFunction(amount);

Além dos problemas de arredondamento, ele também permite qualquer tipo que possa ser convertido em um flutuador:

int amount = 10;
CallSomeFunction(amount);

Nesse caso, não é grande coisa, mas as conversões implícitas podem ser uma fonte de erros difíceis de identificar. Usar a typedefnão ajuda aqui, pois eles são apenas um alias de tipo.

Usar um novo tipo inteiramente significa que não há conversões implícitas, a menos que você codifique um operador de conversão, o que é uma má ideia especificamente porque permite conversões implícitas. Você também pode encapsular dados adicionais:

class Money {
  Decimal amount;
  Currency currency;
};

Money m(Decimal("10.00"), Currency.USD);
CallSomeFunction(m);

Nada mais se encaixará nessa função, a menos que escrevamos código para que isso aconteça. Conversões acidentais são impossíveis. Também podemos escrever tipos mais complexos, conforme necessário, sem muito aborrecimento.

O uso de typedefs para tipos primitivos assim se parece mais com o código de estilo C.

No C ++, você receberá erros interessantes assim que tentar sobrecarregar funções para, digamos, EventLevele Hour. Isso torna os nomes de tipo extra bastante inúteis.

Nós (em nossa empresa) fazemos muito em C ++. Ajuda a entender e manter o código. O que é bom ao mover pessoas entre equipes ou refatorar. Exemplo:

typedef float Price;
typedef int64_t JavaTimestmap;

void f(JavaTimestamp begin, JavaTimestamp end, Price income);

Acreditamos que é uma boa prática criar typedef para o nome da dimensão a partir do tipo de representação. Esse novo nome representa uma função geral em um software. O nome de um parâmetro é uma função local . Como em User sender, User receiver. Em alguns lugares, pode ser redundante void register(User user), mas não considero um problema.

Posteriormente, pode-se ter a idéia de que floatnão é o melhor para representar preços por causa das regras especiais de arredondamento da reserva; portanto, é possível baixar ou implementar um tipo BCDFloat(decimal codificado binário) e alterar o typedef. Não há pesquisa e substituir o trabalho de floatpara BCDFloatque se endureça pelo fato de que existem possivelmente muitos mais carros alegóricos em seu código.

Não é uma bala de prata e tem suas próprias advertências, mas achamos que é muito melhor usá-la do que não.

typedefbasicamente permite que você dê um alias para um type.
Oferece a flexibilidade de evitar a digitação longatype names repetida e repetida e tornar sua typeleitura mais fácil, em que o nome alternativo indica a intenção ou o objetivo da type.

É mais uma questão de escolha se você deseja ter nomes mais legíveis typedefno seu projeto.
Normalmente, evito usar typedeftipos primitivos, a menos que sejam muito longos para serem digitados. Eu mantenho meus nomes de parâmetro mais indicativos.

Eu nunca faria algo assim. Certificar-se de que todos tenham o mesmo tamanho é uma coisa - mas você só precisa se referir a eles como tipos integrais.

Usar typedefs como este é bom, desde que quem os use não precise saber nada sobre sua representação subjacente . Por exemplo, se você deseja passar um PacketLengthobjeto para um printfou outroscanf , precisará conhecer seu tipo real para poder escolher o especificador de conversão correto. Em casos como esse, o typedef apenas adiciona um nível de ofuscação sem comprar nada em troca; você também pode ter definido o objeto como int32_t.

Se você precisar aplicar semântica específica para cada tipo (como intervalos ou valores permitidos), é melhor criar um tipo de dados e funções abstratos para operar com esse tipo, em vez de apenas criar um typedef.