EDUCBA

Home » Software Development » Software Development Tutorials » C ++ Programming Tutorial » C++ using vs typedef

C++ using vs typedef

Definition on C++ using vs typedef

In C++, ‘using’ and ‘typedef’ performs the same task of declaring the type alias. There is no major difference between the two. ‘Using’ in C++ is considered to define the type synonyms. This method is also known as alias- declaration. Defining these alias-declaration works similar to defining the variables in C++ with ‘using’ statement. It helps in improving the overall readability of the code. The ‘using’ in C++ has the ability to create the alias-templates providing the ability for the underlying type, unlike the ‘typedef’ statement. With the use of ‘using’ in C++ code, one can have the usual type aliasing with the same level of abstraction and can specify the template parameters in the future.

‘Typedef’ in C++ performs a similar task of defining the alias. It basically introduces a name that becomes the synonym of the given type using the type declaration within that scope. One of the important features of ‘typedef’ is that it allows the programmer to encapsulate the details of implementation that may change over time. In C++, typedef provides all the facilities like the ‘using’ statement except it does not allow to work with templates which are very useful for the coding perspective. ‘typedef’ declaration does not introduce new types unlike union, enum, class, etc. Instead, they give new names to the already existing type. These new names occupy the same namespace as other identifiers.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Head to Head Comparison Between C++ using vs typedef (Infographics)

Below is the top 8 difference between C++ using vs typedef.

C++ using vs typedef

C++ using vs typedef Comparison Table

Below given is the comparison table depicting the point to point differences between the ‘using’ and ‘typedef’ in C++:

using typedef
‘using’ in C++ also called alias-declaration can be templatized which can be used to create generic templates. These templates can be modified according to the specific requirements in the future. ‘typedef’ in C++ cannot be templatized unlike ‘using’
With the ‘using’ in C++, it is easier to modify the code in the future without hampering the code at a higher level With the use of ‘typedef’ in C++, it is comparatively difficult to modify the code at the later stages.
Creating a generic type alias is easy similar to one given below:

template<typename T>
using Details = std::unordered_map<Stud_id, std::vector<T>>;

 Creating a generic alias using ‘typedef’ on needs to wrap it in a struct similar to one given below in example:

template<typename T>
struct Details {
typedef std::map<Stud_id, std::vector<T>> type;
};
Details<Student_Detail>::type Student_Details;
‘Using’ statement in C++ is not an init-statement so is not used where initialization statements are allowed. In C++, ‘typedef’ is an init-statement so it is used where the initialization statements are allowed.
One of the advantages of ‘using’ statements in C++ is that declaring the function pointer is very clear with that as a comparison to the typedef. Declaring a function pointer using ‘typedef’ is not that much clear like ‘using’.
Creating the alias- templates with the help of ‘using’ statement in C++ does not need any typename before it. ‘typedef’ requires the typename in front of its declaration as wrapped instruct.
Creating aliases with ‘using’ statements helps to develop clean, understandable, and readable code. Although creating an alias using ‘typedef’ is not difficult but it is not that much cleaner and readable as per the programmer’s perspective.
Syntax for declaration with ‘using’ statement:

template<[template-parameters (T1, T2…)]> using [alias] = [original-type];

 Syntax for declaration with ‘typedef’ statement:

typedef struct struct_type short_type_t;

Key Differences between C++ using vs typedef

Some of the key differences between the ‘using’ statement and ‘typedef’ statement in C++ are as follows:

  • One of the major differences between the using statement and typedef statement in C++ is that ‘using’ can perform all the tasks that ‘typedef’ can and also the one that typedef cannot like ‘using’ can also work with templates.
  • Working with ‘using’ statements is very easy and clear from the programmer’s point of view especially when working with function pointers and its alias definition. In fact ‘using’ statement provides more readability to the code as given in the below example:

typedef void(*func_pointer)(int);
vs
using func_pointer = void(*)(int);

  • Alias declaration which is done by both the ‘using’ and ‘typedef’ statements can be done anywhere in the code like in the class, namespaces and inside the blocks, whereas the template declaration which is done only by the ‘using’ statement cannot be declared inside the class and some strict rules needs to be followed for that.
  • For the generic alias, in case of ‘typedef’ , declaration needs to be wrapped in the struct unlike ‘using’ statement which works very easy and clear and does not require wrapping around it. Let us understand this with the help of an example given below:

template<typename T>
using Accounts = std::unordered_map<Student_ID, std::vector<T>>;
Vs
template<typename T>
struct Accounts {
typedef std::map<Student_ID, std::vector<T>> type;
};
//Using the above like:
Accounts<StudentAccount>::type StudentDetailsAccounts;

  • Though the ‘typedef’ allows the declaring of all the types like function pointers, array pointers, etc, it is a bit lengthy and tricky process using it as compared to the ‘using’ statement in C++ which uses only one line code for that. One can also declare the typedef name to the pointer or structure but before defining structure till the definition and declaration has the same visibility.
  • Re- declarations are possible in case of a typedef declaration. One can declare the same variable using typedef in 2 or more different files and no error will be thrown till both refer to the same type.
  • In C++, ‘typedef’ allows the programmer to declare multiple types at once, unlike the ‘using’ statement.

For example:

typedef int X, *ptr, (*Func)();

Conclusion

The above description clearly explains what is ‘using’ and ‘typedef’ statements in C++ and the major difference between the two. Though both are used for creating the type-alias the major limitation of ‘typedef’ is that it does not work with templates. When it comes to work on non-templates, both ‘using’ and ‘typedef’ perform mechanically the same. So it is the personal choice of the programmer what to use in that case.

Recommended Article

This has been a guide to the top differences between C++ using vs typedef. Here we also discuss the key differences with infographics and comparison table. You may also have a look at the following articles to learn more –

  1. C++ vs Visual C++
  2. C++ vs Objective C
  3. C++ vs C#
  4. C++ vs Java
0 Shares
Share
Tweet
Share
quiz