Proper way to define type (typedef vs #define)

Question

Which of these methods is more secure for defining variable types? I know that we all frown when we see #defines, but it seems to work just as well as typedef here:

Is there an advantage one way or the other, and if so what might it be?

Method One:

    #include <iostream>

    #define byte unsigned char

    int main() {
        byte testByte = 'A';
        std::cout << testByte << std::endl;

        return 0;
    }

Method Two:

     #include <iostream>

     int main() {
        typedef unsigned char byte;

        byte testByte = 'A';
        std::cout << testByte << std::endl;

        return 0;
    }

Prefer actual language features over preprocessor features whenever possible. In other words, avoid macros. — Logicrat, Apr 09 '16 at 14:27
#define is dangerous as it does search and replace like operations to your code before compiling. Wrong things could be substituted. — totoro, Apr 09 '16 at 14:27

songyuanyao · Answer 1 · 2016-04-09T14:52:49.820

13

You should always use the 2nd one (i.e. typedef or using).

Try to not use macros in c++ as far as possible, and most cases could be avoided. They're just text replacement before compiling, and more "dangerous". e.g.

#define byte_pointer unsigned char*
byte_pointer p, q; // only p is a pointer

edited Apr 09 '16 at 14:52

answered Apr 09 '16 at 14:25

songyuanyao

169,198
16
310
405

2

Great! Thank you for the answer – James Parkerson Apr 09 '16 at 14:28
I should also mention that that you should define a separate header with these `using` or `typedef` declarations, it will not only scope everything to a single file, but allow you too change values in one and only one place. – Nowhere Man Apr 09 '16 at 15:43

score 6 · Answer 2 · answered Apr 09 '16 at 15:00

Only one of your examples actually is a way to define a type, so there's no contest between them.

#define byte unsigned char

This just makes all utterances of byte in your code get replaced with unsigned char before compilation begins. It does not define a type.

The declaration int byte; will become int unsigned char;, which is nonsense.

typedef unsigned char byte;

This defines a type. The type will be subject to syntax rules, scoping rules and all of that lovely stuff.

The declaration int byte; will still be the declaration int byte;, because byte here is found in the space for a variable name.

using byte = unsigned char;

This is the "modern" way to define a type alias, which has much clearer syntax than a typedef statement (especially for more complex types).

It was introduced because otherwise the new syntax for template type aliases would have been next to impossible to make sane.

score 1 · Answer 3 · edited May 23 '17 at 11:52

1

Using #define is not safe (see other answer) Using typedef is the usual way to define types aliases.

There's also the new "using" syntax

using MyByte = unsigned char;

see this answer to a related question (typedef vs. using) https://stackoverflow.com/a/10748056/446303

edited May 23 '17 at 11:52

Community

1
1

answered Apr 09 '16 at 14:28

Max

3,128
1
24
24

score 0 · Answer 4 · answered Apr 09 '16 at 14:29

Go with the typedef. There are many reasons, but the first one that comes to mind is that the typedef applies to the scope where it is declared, but the #define ignores scope and applies to the remainder of whatever source module it is defined in. For that reason alone, the typedef is "safer".

Proper way to define type (typedef vs #define)

4 Answers4

Linked

Related