C ++ - What's the difference between using fixed types of C ++ and typedef of a type?

It seems that the question boils down to "what are the advantages of using fixed types of the standard library (e.g., std::uint8_t ) instead of non-fixed types (e.g. unsigned char )."

Well, the advantages are (the following is not exhaustive):

• The size in bits remains the same in any environment. You know that an integer std::uint8_t will always have 8 bits, regardless of which environment (i.e., the platform) the code is compiled and executed. In the case of type like char , its only guarantee is that sizeof(char) == 1 , and that sizeof(char) <= sizeof(short) , nothing else. There is no information about the bit size of these types, and they can vary from environment to environment. This is the number one problem fixed types solve. Implementing these types can take advantage of the normal types, as you've already noted. Implementation does not matter, what matters is the assurances and implications of fixed size types. Addendum: These fixed-size types of the standard C ++ library are optional, so it is possible that an implementation does not provide them (in practice this is unlikely nowadays).
• Everyone knows these types and knows their implications. Since these fixed types are in C ++ standardization, it is assumed that the programmer knows its use cases, implications and behaviors. If the programmer defines a new type, another programmer will not know of its existence, so he needs to learn about all the points I've listed. This creates unnecessary friction, since already known types already exist in standardization precisely because of this.
• Specific problems require specific types. The type std::size_t is used to store all possible values of sizeof in an environment. The type std::ptrdiff_t is the result type of the result of subtracting two pointers, and is used for pointer arithmetic and array indexing. The type std::max_align_t has the property of having its alignment as large as any other scalar type. The type std::byte represents raw byte values. The type std::intmax_t is the largest type in bits. The type std::int32_t ensures that it is 32 bits in size, has no padding and uses 2's complement for negative numbers. Anyway, each type has its implications, use cases etc.

You can see all fixed size types here: link . Some other types are here: link

The difference between an array in C and a std::array is basically the interface of it. The std::array has a container interface (like std::vector , for example), so you have a number of features, such as knowing the size of the array, being able to use it in STL algorithms (since it has begin and end ), limits checking, and also if in the future you need to switch to a dynamic allocation container, just switch to std::vector and all your code will work as before. Finally, in terms of performance the two should have the same performance.

As for typedef , it just creates a nickname for the type, but in the end it's the same type. It is usually used to give meaning to the type. But prefer the using which is the equivalent in C ++. typedef exists only for C compatibility.

typedef unsigned char BYTE; // C
using BYTE = unsigned char; // C++ 

Without seeing the context, it is a bit difficult to answer, including because it is common for the person explaining what he has read wrong.