Article directory
1. Decimals in C language
Decimals are divided into integer parts and decimal parts, which are separated by periods., such as0.0,75.0,4.023,0.27,-937.198,-0.27, etc. are all legal decimals, which is the most common The decimal form of , we call it thedecimal form. In addition, decimals can also be in exponential form, such as 7.25×102, 0.0368×10< a i=7>5, 100.22×10-2, -27.36×-3 etc. Any decimal can be expressed in exponential form. C language supports both the above forms of decimals. But when writing, the exponential form in C language and the exponential form in mathematics are different. The exponential form of decimals in C language is:
aEn 或 aen
a is the mantissa part, which is a decimal number; n is the exponent part, which is a decimal integer; E or e is a fixed character, used to separate the mantissa part and the exponent part. The entire expression is equivalent to a×10n. Examples of decimals in exponential form:
- 2.1E5 = 2.1×105, of which 2.1 Koreo number, 5 Korei exponent.
- 3.7E-2 = 3.7×10-2, of which 3.7 is the number of koreo, and -2 is the index.
- 0.5E7 = 0.5×7, where 0.5 is the mantissa and 7 is the exponent.
C language provides 3 decimal types, namely float, double and long double. The first two are the most used. float is calledsingle-precision floating-point type, and double is calleddouble-precision floating-point type, long double is calledlong double precision floating point type.
The lengths of the float and double types are fixed, with float always occupying 4 bytes and double always occupying 8 bytes. The C language only stipulates that the length of long double is at least the same as double. The actual test result is that this type occupies 8 bytes in the Windows environment and 16 bytes in the 64-bit Linux environment.
#include <stdio.h>
int main()
{
long double a = 23.45;
printf("a=%Lf\n", a);
printf("sizeof(long double)=%zd", sizeof(a));
return 0;
}
The program running result is as shown below:
Test under Linux:
1.1 Output of decimals
Decimals can also be output using the printf function, including decimal and exponential forms. Their corresponding format control characters are:
%f 以十进制形式输出 float 类型
%lf 以十进制形式输出 double 类型
%Lf 以十进制形式输出 long double 类型
%e 以指数形式输出 float 类型，输出结果中的 e 小写
%E 以指数形式输出 float 类型，输出结果中的 E 大写
%le 以指数形式输出 double 类型，输出结果中的 e 小写
%lE 以指数形式输出 double 类型，输出结果中的 E 大写
%Le 以指数形式输出 long double 类型，输出结果中的 e 小写
%LE 以指数形式输出 long double 类型，输出结果中的 E 大写
The following code demonstrates decimal representation and output:
#include <stdio.h>
#include <stdlib.h>
int main()
{
float a = 128.101;
double b = 0.302;
long double c = 123;
float d = 112.64E3;
double e = 0.7623e-2;
long double f = 1.23002398;
printf("a=%f \nb=%f \nc=%Lf \nd=%E \ne=%lf \nf=%Lf\n", a, b, c, d, e, f);
return 0;
}
The program running result is as shown below:
Description of the code:
- %f, %lf and %Lf retain six decimal places by default. If there are less than six decimal places, they will be padded with 0. If there are more than six decimal places, they will be rounded off.
- When an integer is assigned to a floating-point variable, it becomes a decimal.
- When outputting decimals in exponential form, the output result is scientific notation; that is, the value of the mantissa part is: 0 ≤ mantissa < 10.
- The output result of a is puzzling. It only has three decimal places. Why can't it be output accurately, but an approximate value? This is related to the storage form of decimals in memory. Many simple decimals cannot be stored accurately at all, so they cannot be output accurately. The author will discuss the representation and operation of data in the principle of computer composition (2) ) for detailed explanation.
In addition, there is a more intelligent way to output decimals, which is to use %g. %g will compare the decimal form and exponential form of the decimal, and output the decimal in the shortest way, making the output result more concise. The so-called shortest means that the output result occupies the least characters. %g usage example:
#include <stdio.h>
#include <stdlib.h>
int main()
{
float a = 0.00001;
float b = 30000000;
float c = 12.84;
float d = 1.229338455;
printf("a=%g \nb=%g \nc=%g \nd=%g\n", a, b, c, d);
return 0;
}
The program running result is shown in the figure below:
Analysis of each decimal:
- The decimal form of a is 0.00001, occupying seven characters. The exponential form of a is 1e-05, occupying five characters. The exponential form is shorter, so it is output in exponential form.
- The decimal form of b is 30000000, occupying eight characters. The exponential form of b is 3e+07, occupying five characters. The exponential form is shorter, so it is output in exponential form.
- The decimal form of c is 12.84, which occupies five characters. The exponential form of c is 1.284e+01, which occupies nine characters. The decimal form is shorter, so it is output in decimal form.
- The decimal form of d is 1.22934, which occupies seven characters. The exponential form of d is 1.22934e+00, which occupies eleven characters. The decimal form is shorter, so it is output in decimal form.
Two points that readers need to pay attention to are:
%g 默认最多保留六位有效数字，包括整数部分和小数部分；%f 和 %e 默认保留六位小数，只包括小数部分
%g 不会在最后强加 0 来凑够有效数字的位数，而 %f 和 %e 会在最后强加 0 来凑够小数部分的位数
In short, %g should output decimals in the shortest way, and the decimal part behaves naturally without imposing zero. It is more flexible than %f and %e, which is in line with user habits in most cases. In addition to %g, there are also %lg, %Lg, %G, %lG, and %LG:
%g、%lg 和 %Lg 分别用来输出 float、double 和 long double 类型，并且当以指数形式输出时，e小写
%G、%lG 和 %LG 分别用来输出 float、double 和 long double 类型，只是当以指数形式输出时，E大写
1.2 Decimal suffixes
In C language, the default decimal type is double. Please see the following example:
float x = 52.55;
double y = 18.6;
The two numbers 52.55 and 18.6 are of double type by default. To assign 52.55 to x, you must first convert from the double type to the float type, while assigning 18.6 to y does not require conversion. If you don't want the decimal to use the default type, you can add a suffix to the decimal and manually specify the type:
小数后面紧跟 f 或者 F（不区分大小写），表明它是 float 类型
小数后面紧跟 l 或者 L（不区分大小写），表明它是 long double 类型
Please look at the code below:
float x = 52.55f;
double y = 18.6F;
float z = 0.02;
With the addition of the suffix, although the type of the decimal has changed, this does not mean that the decimal can only be assigned to the corresponding type. It can still be assigned to other types, as long as a type conversion is performed. For beginners, numerical suffixes are rarely used. There is usually no difference between adding them or not, and it does not affect the actual programming. However, since you have learned C language, you still need to know this knowledge point, in case you see other people's code like this If you use it and you don’t understand what’s going on, that would be embarrassing. Regarding data type conversion, we will discuss it in depth in the section "C Language Data Type Conversion" later in this article.
1.3 Decimals and integers assign values to each other
In C language, integers and decimals can be assigned to each other:
- To assign an integer to a decimal type, just add 0 after the decimal point. It doesn't matter how many you add.
- When assigning a decimal value to an integer type, you have to discard the decimal part and only take the integer part, which will change the original value of the number. Note that the decimal part is discarded directly instead of rounding to approximate the value.
Example:
#include <stdio.h>
int main(){
float f = 251;
int w = 19.427;
int x = 92.78;
int y = 0.52;
int z = -87.27;
printf("f = %f, w = %d, x = %d, y = %d, z = %d\n", f, w, x, y, z);
return 0;
}
The program running result is as shown below:
Since when assigning decimals to integer types, 失真, Therefore, the compiler usually gives a warning to draw attention to it, as shown in the figure below:
2. Using English characters in C language
The character types often used by beginners arechar,. Its length is 1 and can only accommodate characters in the ASCII code table. Just English characters. If you want to process characters other than English such as Chinese, Japanese, Korean, etc., you have to use other character types, which cannot be done with char.
2.1 Representation of characters
Character types are surrounded by single quotes ' ' and strings are surrounded by double quotes " ". The following example demonstrates how to assign a value to a variable of type char:
//正确的写法
char a = '1';
char b = '$';
char c = 'X';
char d = ' '; // 空格也是一个字符
//错误的写法
char x = '中'; //char 类型不能包含 ASCII 编码之外的字符
char y = 'Ｂ'; //B 是一个全角字符
char z = "t"; //字符类型应该由单引号包围
Note: In the character set, the numbers (or encoding values) corresponding to full-width characters and half-width characters are different, and they are two characters; ASCII encoding only defines half-width characters, not full-width characters.
2.2 Character output
There are two methods for outputting characters of type char, namely:
- Use the specialized character output function putchar
- Use the general formatted output function printf. The corresponding format control character for char is %c.
Example:
#include <stdio.h>
int main() {
char a = '1';
char b = '$';
char c = 'X';
char d = ' ';
//使用 putchar 输出
putchar(a); putchar(d);
putchar(b); putchar(d);
putchar(c); putchar('\n');
//使用 printf 输出
printf("%c %c %c\n", a, b, c);
return 0;
}
The program running result is as shown below:
The putchar function can only output one character at a time, and it needs to be called multiple times to output multiple characters.
2.3 Characters and integers
We know that when the computer stores characters, it does not really store the character entity, but stores the number of the character in the character set (also called the coded value). For the char type, it actually stores the ASCII code of the character. No matter which character set it is in, the character number is an integer; from this perspective, there is essentially no difference between character types and integer types. We can assign an integer to the character type, or output the character type as an integer. Conversely, you can also assign a character to an integer type, or output an integer type in the form of a character. Please see the following example:
#include <stdio.h>
int main()
{
char a = 'E';
char b = 70;
int c = 71;
int d = 'H';
printf("a: %c, %hhd\n", a, a);
printf("b: %c, %hhd\n", b, b);
printf("c: %c, %d\n", c, c);
printf("d: %c, %d\n", d, d);
return 0;
}
The program running result is as shown below:
In the ASCII code table, the characters 'E', 'F', < The corresponding numbers for /span> as the format control character. If the reader's compiler does not support the C99 standard, you can use %d instead. a, b, c, d actually store integers: are 69, 70, 71, and 72 respectively. Output the character type in integer form. The C99 standard recommends using 'G' and 'H'%hhd
- When assigning a character to a or d, the character will be converted into ASCII code first and then stored;
- When assigning an integer to b and c, no conversion is required, just store it directly;
- When a, b, c, d are output with %c, the integers will be converted into corresponding characters according to the ASCII code table;
- When outputting a, b, c, d with %d, no conversion is required, just output directly.
It can be said that the ASCII code table associates English characters with integers.
What is ASCII code?
This section has been talking about ASCII code, so what is ASCII? ASCII (American Standard Code for Information Interchange, American Standard Code for Information Interchange) is a computer coding system. There are 128 standard ASCII codes in total, including numbers, control symbols, upper and lower case letters, punctuation marks, operators, etc. In the C language, the characters used are mapped one by one to a table. This table is called the ASCII code table. By clicking the link https://tool.oschina.net/commons ?type=4 You can view the ASCII code table
Remember 52 ASCII codes in one second
There are rules between uppercase and lowercase letters in ASCII codes. As long as you remember the rules and the value of one letter, you can remember 52 ASCII code values. Next, we will introduce the ASCII values of uppercase and lowercase letters. Little secret. Here we use a, A and B to illustrate. The relationship between the ASCII code values of a and A is shown in the figure below:
The ASCII code value of a is 97, and the ASCII code value of A is 65. The difference between these two values is 32, which is known as lowercase The ASCII value of the letter. Subtract 32 from this value to get the corresponding uppercase letter. The relationship between the ASCII code values of A and B is shown in the figure below:
The ASCII code value of A is 65, the ASCII code value of B is 66, the ASCII code values of A and B differ by 1, similarly The ASCII code values of B and C also differ by 1, and so on; that is, if you know the ASCII code value of one letter, you know the ASCII code values of 26 uppercase letters. Through these two little secrets, as long as we remember the ASCII code value of one letter, we can remember the ASCII code value of a total of 52 uppercase and lowercase letters.
2.4 C language escape characters
Character Set assigns a unique number to each character, which we might as well call a coded value. In the C language, a character can not only be represented by its entity (that is, a real character), but also by an encoded value. This way of using an encoded value to represent a character indirectly is called an Escape Character.
The escape character starts with \ or \x, and starts with \ to represent the encoded value in octal form, starting with Starting with \x means followed by the encoded value in hexadecimal form. For escape characters, only octal or hexadecimal can be used. The octal forms of the ASCII codes corresponding to characters 1, 2, 3, a, b, and c are 61, 62, 63, 141, 142, 143, respectively, and the hexadecimal forms are 31, 32, 33, 61, 62, 63. The following example demonstrates the use of escape characters:
char a = '\61'; //字符1
char b = '\141'; //字符a
char c = '\x31'; //字符1
char d = '\x61'; //字符a
char *str1 = "\x31\x32\x33\x61\x62\x63"; //字符串"123abc" 字符串的定义后面再说
char *str2 = "\61\62\63\141\142\143"; //字符串"123abc"
char *str3 = "The string is: \61\62\63\x61\x62\x63" //混用八进制和十六进制形式
Escape characters can be used for both single characters and strings, and both octal and hexadecimal forms can be used in a string. Example:
#include<stdio.h>
int main() {
char a = '\61'; //字符1
char b = '\141'; //字符a
char c = '\x31'; //字符1
char d = '\x61'; //字符a
printf("a=%c\n", a);
printf("b=%c\n", b);
printf("c=%c\n", c);
printf("d=%c\n", d);
}
The program running result is as shown below:
The original intention of the escape character is for ASCII encoding, so its value range is limited:
- The escape character in octal form can be followed by up to three digits, that is,
\ddd, and the maximum value is\177 - The escape character in hexadecimal form can be followed by up to two digits, that is,
\xdd, and the maximum value is\x7f
The behavior of out-of-range escape characters is undefined. Some compilers will output the encoded value directly, and some compilers will report an error. For ASCII encoding, characters in the range 0~31 (decimal) are control characters. They are invisible and cannot be displayed on the monitor, even It cannot be entered from the keyboard and can only be expressed in the form of escape characters. However, it is inconvenient to use ASCII codes directly to remember and understand. Therefore, C language defines abbreviations for commonly used control characters. The complete list is as follows:
\n and \t are the two most commonly used escape characters:
\nUsed to break lines so that text is output from the beginning of the next line. It has been used many times in previous chapters;\tUsed to occupy space, generally equivalent to four spaces, or the function of the tab key.
Single quotes, double quotes, and backslashes are special characters and cannot be expressed directly:
- The single quotation mark is the beginning and end of the character type, which should be expressed by
\', that is,'\'' - Double quotation marks are the beginning and end of the string, which should be represented by
\", that is,"abc\"123" - The backslash is the beginning of the escape character and should be represented by
\\, that is,'\\', or"abc\\123"
4. C language Boolean type (_BOOL)
In some scenarios, there are only two situations for the value of a variable. For example, if the variable sex is used to represent a person's gender, its values are only '男' and '女', and there are no other possibilities. Through the previous study, readers have mastered many data types, such as char, short, int, long, float, double, etc. So, for a variable with only two values, what should its type be? Before the release of the C99 standard, there was no fully compatible data type for variables that had only two values. The next best thing is to usually choose int as the type of variable. The value range of the int type is [-2147483648,2147483647], By dividing these values into two categories: 0 and non-0 numbers, you can simulate "变量只有两种取值" situation. For example, use the int type variable sex to represent a person's gender. When the value of sex is 0, it represents a female; when the value of sex is a non-zero number, it represents a male. In order to solve this historical problem, the C99 standard introduced the _Bool type, which is called the Boolean type in Chinese. Variables defined as Boolean types can only store 0 or 1. If other non-zero numbers are assigned, the value of the variable will be set to 1. For example:
#include <stdio.h>
int main()
{
_Bool sex = 0;
_Bool sex1 = 1;
_Bool sex2 = 1234;
printf("sex = %d\n", sex);
printf("sex1 = %d\n", sex1);
printf("sex2 = %d\n", sex2);
return 0;
}
The program running result is as shown below:
printf() outputs a bool type value. The format control symbol can be %d or %hd. They can both be accommodated_ Two values of type Bool (0 and 1). The length of the _Bool type is the same as char and only occupies 1 byte. You can also use the sizeof operator to check the length of the _Bool type:
#include <stdio.h>
int main()
{
printf("%d", sizeof(_Bool));
return 0;
}
The program running result is as shown below:
Boolean type(_Bool) starts with an underscore_, and the first letter must be Capitalization, compared with the type char,float,int,float we have mastered before, has a bigger way of writing, and beginners will find it somewhat awkward. In fact, in addition to C language, many programming languages provide Boolean types, such as C++,Java,C#, etc. Most of them use bool/boolean as the name of the Boolean type, and The two values of the Boolean type are false (false) and true (true)_Bool< a i=10> means that false represents 0 and true represents 1. Perhaps influenced by other programming languages, or perhaps considering the feelings of beginners, the C Language Standards Committee decided to introduce the type and add bool as _Bool The alias of the type, and the value of the Boolean type can be represented by true and false. That is to say, in a C language program, the Boolean type can be represented by _Bool or bool. It should be noted that before using the bool type, the <stdbool.h> header file must be introduced. For example:
#include <stdio.h>
#include <stdbool.h> // bool、true、false
int main()
{
bool sex = true;
printf("%d", sex);
return 0;
}
The program running result is as shown below:
Summary: For variables with only two values, the C99 standard recommends setting the variable type to Boolean type, you can use header file. _Bool or bool representation. If the compiler does not support boolean types, the next best thing is to use the int type. In the C99 standard, if you want to use bool to represent the Boolean type, and if you want to use true and false to represent the two values of the Boolean type, you must first introduce the <stdbool.h>
5. Supplement: Several important concepts in C language
5.1 Identifier
When defining variables, we use names such as a, abc, and mn123. They are all given by programmers themselves and can generally express the role of variables. This is called Identifier. Identifiers are names given by programmers themselves. In addition to variable names, function names, macro names, structure names, etc. will also be mentioned later. They are all identifiers. However, the name cannot be chosen casually and must abide by the regulations; C language stipulates that identifiers can only consist of letters (A~Z, a~z), Numbers (0~9) and Underscore (_), and the first character must be a letter or underscore, cannot be a number. Example:
a, x, x3, BOOK_1, sum5 //合法的标识符
//以下是非法的标识符:
3s 不能以数字开头
s*T 出现非法字符*
-3x 不能以减号(-)开头
bowy-1 出现非法字符减号(-)
You must also pay attention to the following points when using identifiers:
- Although the C language does not limit the length of identifiers, it is restricted by different compilers and also by the operating system. For example, a certain compiler stipulates that the first 128 bits of an identifier are valid. When the first 128 bits of two identifiers are the same, they are considered to be the same identifier.
- In identifiers, there is a difference between upper and lower case. For example, BOOK and book are two different identifiers.
- Although identifiers can be defined by programmers at will, identifiers are symbols used to identify a certain quantity. Therefore, the naming should have corresponding meanings as much as possible to facilitate reading and understanding.< a i=1>.
见名知意int a; //长方体的长 int b; //长方体的宽 int c;//长方体的高 // 相比之下，iLong、iWidth、iHeight这样的标识符更清晰、明了，推荐大家采用 int iLong; //长方体的长 int iWidth; //长方体的宽 int iHeight; //长方体的高
5.2 Keywords
The so-called keywords refer to words that are predefined in computer language and contain special meanings, as shown in the program belowint,return:< a i=2> The English words of keywords are all lowercase, especially the first letter also needs to be lowercase. Don’t misspell or misspell English letters, such as return as retrun, or double as duoble. The identifier we define cannot be the same as the keyword, otherwise an error will occur.
You can also understand keywords as identifiers with special meanings that have been used by the system and we can no longer use them.
The keywords in C language are listed below. The keywords with symbols are keywords that appear more frequently in C programs. Readers can gradually learn them during specific use.
Note: When writing code in the development environment, all keywords will be displayed in special fonts (for example, turned into blue, Different editors have different colors), In future studies, you will gradually come into contact with the specific usage of these keywords. There is no need to memorize these keywords by rote, and you can slowly learn them in future studies. Accumulate slowly.
5.3 Comments
When we first learned to recognize English words, every student would have a dictionary. When we encountered an unfamiliar word, we would consult the dictionary to solve the puzzle. The dictionary would give detailed Chinese meanings and specific explanations. The programming language also has such an intimate function, that is, 注释, in the code program is a kind of annotation text that explains and explains the code program. , which can improve the readability of the program for users and also expand the dissemination of the program. Most comments in C language are displayed in green font, of course there are special exceptions (it mainly depends on the editor you use). However, the content of the annotation will be ignored by the C language compiler and will not be reflected in the execution results. C language mainly provides three types of code comments, namely single-line comments, multi-line comments and document comments, which are introduced below.
① Single line comment. There are two forms of single-line comments:
----------第一种形式:----------
//这里是注释
"//" 为单行注释标记，从符号 "//" 开始直到换行为止的所有内容均作为注释而被编译器忽略
//以下代码为printf()语句添加注释
// ① 在控制台输出sex
printf("%d", sex); // ② 在控制台输出sex
----------第二种形式:----------
/*这里是注释*/ ⇒ 符号 "/*" 与 "*/" 之间的所有内容均为注释内容
/* ① 在控制台输出sex */
printf("%d", sex); /* ② 在控制台输出sex */
② Multi-line comments.
/*
注释内容1
注释内容2
…
*/
"/* */" 为多行注释标记，符号 "/*" 与 "*/" 之间的所有内容均为注释内容。注释中的内容可以换行
举例:
/*
* 版权所有：dream公司
* 文件名：Dome.c
* 文件功能描述： 多行注释测试
* 创建日期：2023年10月
* 创建人：AmoXiang
*/
③ Documentation comments. In C language, there are also documentation comments. Its format is as follows:
/**
注释声明
*/
/**…*/ is the document comment mark, and the content between the symbols /** and */ is the document comment content. The biggest difference between documentation comments and general comments is that the starting symbol is /** instead of /* or //. For example, the following comments the main() function using documentation comments:
/**
* 主方法，程序入口
* args、argv-主函数参数
*/
int main(){
语句;
return 0;
}
Note: The differences between multi-line comments and documentation comments are as follows:
- Documentation comments are generally placed at the very beginning of the code, while multi-line comments can be placed at the end of the statement.
- You can use multi-line comments to comment out unnecessary code to debug the program, but document comments cannot do this.
Comments are instructions for the code, describing things like 这个代码是做什么的?/使用这个代码要注意什么. Do not write junk comments. For example, the following three comments are junk comments:
int a = 1; // int a
int c = a; // 让c等于a
c=a+a; //计算a+a的值赋给c
It should be noted that multi-line comments cannot be nested. For example, the following comment is incorrect:
/*我/*爱*/你*/
//正确的
/*我爱你*/ /*I Love You!*/
5.4 Expression and Statement
The concepts of Expression and Statement do not exist in C language Clear definition:
- Expression can be regarded as a calculation formula, which is often composed of data, variables, operators, etc., such as
3*4+5,a=c=d, etc. The result of the expression must be a value; - The scope of statements is wider. It does not necessarily have to be a calculation or have a value. It can be an operation, a function, a selection structure, a loop, etc.
Quickly highlight:
- The expression must have an execution result, which must be a value, such as the result of , is 10, and the result of is 5 (the return value of printf is the number of characters successfully printed).
3*4+517a=c=d=10printf("hello") - ends with a semicolon
;is often called a statement rather than an expression, such as3*4+5;/a=c=d;etc.
This concludes today’s study. The author declares here that the author writes articles only for learning and communication, so that more readers who learn C language can avoid detours and save time. It is not used for other purposes. If there is any infringement, Just contact the blogger to delete it. Thank you for reading this blog post. I hope this article can be a guide on your programming journey. Happy reading!
I never get tired of reading a good book a hundred times, and I will know myself after reading the lessons thoroughly. And if I want to be the most handsome guy in the room, I must persist in acquiring more knowledge through learning, use knowledge to change my destiny, use my blog to witness my growth, and use my actions to prove that I am working hard.
If my blog is helpful to you, if you like my blog content, please点赞,评论,收藏me!
Coding is not easy, and everyone’s support is what keeps me going. Don’t forget to like Three consecutive hits with one click! I heard that those who like it will not have bad luck and will be full of energy every day! If you really want to have sex for nothing, then I wish you a happy day every day, and you are welcome to visit my blog often.关注