preface 👦
The conclusion of this chapter will be summarized in combination with three C language books, describing the basic types of data, the use and scope of data types, when to use which data type is more appropriate.
1, What are the data types of C? What is it? 🥴
C language has only 4 data types:
- Integer;
- Floating point type;
- Pointer;
- Aggregation type;
- Other types: all derived from the above four types.
1.1 data type keywords
int,long,short,char,float,double,unsigned,signed(C90),void(C90),_Bool(C99),_Complex(C99),_Imaginary(C99)ï¼›
View size
#include<stdio.h> #include<stdlib.h> int main(){ printf("int:%d bytes\n", sizeof(int)); printf("char:%d byte\n", sizeof(char)); /* char The number of bytes of type is 1 */ printf("short:%d bytes\n", sizeof(short)); /* short The number of bytes of type is 2 */ printf("long:%d bytes\n", sizeof(long)); /* long The number of bytes of type is 4 */ printf("float:%d bytes\n", sizeof(float)); /* float The number of bytes of type is 4 */ printf("double:%d bytes\n", sizeof(double)); /* double The number of bytes of type is 8 */ printf("long double:%d bytes\n", sizeof(long double)); /* long double Type has 8 or 10 or 12 bytes */ system("pause"); return 0; }
Then let's expand according to the above types... [Note: there are many contents of pointer and aggregation, which will be summarized separately later]
2, Introduction to data types 😲
1.1 integer data type
Integers include characters, short integers, integers, and long integers. [some students may wonder why characters belong to integer type???] because computers use digital coding. Commonly used is ASCII encoding, using special integers to represent specific characters. For example, as you will learn later, all the characters read by the file reading function are basically of type int, marked with EOF(-1).
1.1.1 int type
use
It must be declared before use;
int i; int k,j; int m=10;
View integer size
- int type length is related not only to the specific CPU architecture, but also to the compiler.
- There are three criteria for determining the int length:
- â‘ C/C + + specifies that the int word length is the same as the machine word length;
- â‘¡ The word length of the operating system may not be the same as that of the machine; (the former is less than or equal to the latter)
- â‘¢ The compiler defines the int word length according to the word length of the operating system;
#include<stdlib.h> #include<stdio.h> #include<limits.h> int main(){ printf("minimum(Signed)Integer:%d\n", INT_MIN); printf("maximum(Signed)Integer:%d\n", INT_MAX); printf("maximum(Unsigned)Integer:%d\n", UINT_MAX); system("pause"); }
Understand what words are
- Word is a natural storage unit given when designing a computer;
- It is a term used to describe computer data unit or storage unit together with bit and byte;
- 1 is only 8 bits long, and 64 bits have appeared today;
- The longer the word, the faster the computer data transmission and the more memory allowed to be accessed.
1.1.2 short type
The storage space occupied may be less than that of int type. It is suitable for occasions with small values to save space;
View short integer size
#include<stdio.h> #include<stdlib.h> #include<limits.h> int main(){ printf("minimum(Signed)Short value:%d\n", SHRT_MIN); printf("maximum(Signed)Short value:%d\n", SHRT_MAX); printf("maximum(Unsigned)Short value:%d\n", USHRT_MAX); system("pause"); }
1.1.3 long type
It may occupy more storage space than int, which is suitable for large numerical occasions;
View long integer size
#include<stdio.h> #include<stdlib.h> #include<limits.h> int main(){ // Long integer printf("--------------------------------------------\n"); printf("minimum(Signed)Long integer:%d\n", LONG_MIN); printf("maximum(Signed)Long integer:%d\n", LONG_MAX); printf("maximum(Unsigned)Long integer:%d\n", ULONG_MAX); // long long printf("--------------------------------------------\n"); printf("minimum(Signed)Long integer:%d\n", LLONG_MIN); printf("maximum(Signed)Long integer:%d\n", LLONG_MAX); printf("maximum(Unsigned)Long integer:%d\n", ULLONG_MAX); system("pause"); }
With the long type, why is there the long type?
At present, computers are generally 64 bit processors, which is introduced in order to store 64 bit integers;
More common: long long(64 bits), long(32 bits), short(16 bits), int(16 bits / 32 bits);
11.4 signed and unsigned keywords
Signed: [optional] you can add a declaration before any signed keyword for emphasis, including negative numbers.
Unsigned: [required] to indicate unsigned, you need to add before the keyword, only 0 and positive numbers;
1.1.5 char type
- Storing letters or punctuation marks to accommodate string type values;
- A storage unit stored in 8 bits.
#include<stdio.h> #include<stdlib.h> int main(){ char a = 'AXDF'; // Storage unit stored in 8 bits printf("ret: %c\n", a); system("pause"); } // Since the storage unit is 8 bits, only the last 8 bits are valid
View character size
#include<limits.h> #include<stdio.h> #include<stdlib.h> int main(){ printf("Number of digits of one character:%d\n", CHAR_BIT); printf("minimum(Signed)Character type:%d\n", SCHAR_MIN); printf("maximum(Signed)Character type:%d\n", SCHAR_MAX); printf("maximum(Unsigned)Character type:%d\n", UCHAR_MAX); system("pause"); }
1.1.6 _Bool type
It is usually used for logical judgment, that is, true and false, accounting for only 1 bit of storage space;
1.1.7 _Complex type
Plural: float_Complex,double_Complex,long double_Complexï¼›
1.1.8 _ Imaging type
Represents an imaginary number: float_Imaginary,double_Imaginary,long double_Imaginaryï¼›
1.1.9 precautions:
- It cannot be understood literally. Long integers must be longer than short integers, which are not specified in the standard, but cannot be shorter than short integers;
- Long integers should be at least as long as integers, and integers should be at least as long as short integers;
- Try not to use unsigned types in code, even if the data represented does not have negative values;
- Generally, unsigned numbers can be used only when bit segments and binary masks are used;
1.2 floating point data types
1.2.1 float type
- Floating point type, usually an approximation of the actual value. If 10.0 may store bit 9.99999;
- Generally, it can be accurate to at least 6 significant digits, and the range is generally 10-37 ~ 10 + 37;
Counting method
- Number: 12.123;
- Scientific counting method: 1.2x107;
- Index counting method: 1.2e7;
#include<stdio.h> #include<stdlib.h> int main(){ float f = 112.231; printf("%f\n", f); printf("%e\n", f); system("pause"); }
View float range
#include<stdio.h> #include<stdlib.h> #include <float.h> int main(){ printf("minimum float Value:%e\n", FLT_MIN); printf("maximum float Value:%e\n", FLT_MAX); system("pause"); return 0; }
1.2.2 double type
- It is double precision, accounting for 64 bits, which improves the precision;
- At least 10 significant digits;
- There is also a long double to meet the needs of higher precision;
View double range
#include<stdio.h> #include<stdlib.h> #include <float.h> int main(){ printf("minimum double Value:%e\n", DBL_MIN); printf("maximum double Value:%e\n", DBL_MAX); system("pause"); return 0; }
3, Portability issues in use
In order to unify, some types of functions are the same in each system. In 1999, ANSI introduced C99 and added header files stdint.h and inttypes.h.
Therefore, in the development process, in order to avoid problems in the migration process, try to use the two header files to define variables;
3.1 introduction to header file stdint.h
typedef defines the type | Unsigned type | describe |
---|---|---|
intmax_t | uintmax_t | Integer type of maximum width |
int8_t | uint8_t | An integer type with a width of 8 bits. For signed types, negative values are represented by the complement of 2 |
int16_t | uint16_t | An integer type with a width of 16 bits. For signed types, negative values are represented by the complement of 2 |
int32_t | uint32_t | An integer type with a width of 32 bits. For signed types, negative values are represented by the complement of 2 |
int64_t | uint64_t | An integer type with a width of 64 bits. For signed types, negative values are represented by the complement of 2 |
int_least8_t | uint_least8_t | Minimum 8-bit integer type |
int_least16_t | uint_least16_t | Minimum 16 bit integer type |
int_least32_t | uint_least32_t | Minimum 32-bit integer type |
int_least64_t | uint_least64_t | Minimum 64 bit integer type |
int_fast8_t | uint_fast8_t | Minimum 8-bit integer type |
int_fast16_t | uint_fast16_t | Minimum 16 bit integer type |
int_fast32_t | uint_fast32_t | Minimum 32-bit integer type |
int_fast64_t | uint_fast64_t | Minimum 64 bit integer type |
intptr_t | uintptr_t | Integer type, which can save the value converted from void pointer, and then convert it back to the type of value equal to the original pointer |
3.2 portable code shall comply with the following standards
- Use only identified characteristics;
- Do not break through any limitations implemented by the compiler;
- Does not produce any output that depends on compiler defined or undefined or undefined properties.