​

preface:

1. When any character is stored, its ascii code value (integer int type) is stored in memory.
2. Write the function according to the document

3. Library function, user-defined function (with function name, return value type and function parameters)

1.getchar, putchar function

Example 1:

int main()
{
	int ch = getchar();
		putchar(ch);
	return 0;
}

Example 2:

int main()
{
	int ret = 0;
	char password[20] = { 0 };
	printf("Enter the password first\n");
	scanf("%s", password);
	printf("Please confirm( y/n)");
	ret = getchar();
	if (ret =='y')
	{
		printf("correct");
	}
	else
	{
		printf("error");
	}
	return 0;
}

​

Hypothesis 1: if we enter 123456 and press enter, there will be no execution process of getchar function, and the result is:

​

Explanation: the execution logic is different from the logic we want: password and getchar are input functions. The input function should first detect the input buffer, which may put some data. When the input function receives data, the scanf function first reads the input buffer (there is nothing at first, waiting for input) , once there is something in the input buffer, the scanf function takes away a part. After taking it away, the scanf function passes and the getchar function arrives (for example, after you enter 123456, hit the Enter key to make the scanf function read 123456, and the buffer remains \ n), and then getchar reads \ n without waiting.

Solution: (solve how to make there is no '\ n' in the input buffer) read '\ n' with a getchar()

int main()
{
	int ret = 0;
	char password[20] = { 0 };
	printf("Enter the password first\n");
	scanf("%s", password);
	getchar();//Read '\ n'
	printf("Please confirm( y/n)");
	ret = getchar();
	if (ret =='y')
	{
		printf("correct");
	}
	else
	{
		printf("error");
	}
	return 0;
}

Hypothesis 2: after adding getchar (), when we enter 123456 (space) ABCD, the result is:

Analysis: enter 123456 ABCD, the scanf function reads 123456, getchar reads spaces, and ret=getchar() reads' A ', so the print error.

<font color="orae" size="3">Solution: add a loop until you read to'\n'Jump out of the loop.

int main()
{
	int ret = 0;
	int ch = 0;
	char password[20] = { 0 };
	printf("Enter the password first\n");
	scanf("%s", password);
	while ((ch = getchar()) != '\n')
	{
		;
	}
	printf("Please confirm( y/n)");
	ret = getchar();
	if (ret =='y')
	{
		printf("correct\n");
	}
	else
	{
		printf("error\n");
	}
	return 0;
}

Add a question:

int main()
{
	int ch = 0;
	while ((ch = getchar()) != EOF)
	{
		if (ch < '0' || ch > '9')
			continue;
		putchar(ch);
	}
	return 9;
}

In this code, if (CH < '0' | ch > '9') is interpreted from the perspective of asc code value

Operator

Note: as long as the operation is performed, the complement in memory is used, but the premise of this complement is that the concept of original inverse complement exists only for integers, and non integers are not the concept of original inverse complement.

Classification:

Arithmetic, shift, bit, assignment, unary, relation, logic, condition, comma (expression), subscript reference, function call, structure member

Arithmetic operators: +, -, *, /,%

1. Example of division:

main()
{
	int a = 5 / 2;//Quotient 2 more than 1,5 / 2 get quotient
	printf("a=%d\n", a);
}

   why isn't a equal to 2.5? Because the numbers at both ends of the division sign are 5 and 2, both of which are integers. If you perform integer division, you won't get decimal results.
   if any number at both ends of the division sign (/) is a decimal, then the division of floating-point numbers is executed, and this can be saved with floating-point numbers (i.e., double,%lf).

main()
{
	double a = 5.0 /2;//Shang 2 Yu 1
	printf("a=%lf\n", a);
}

2. Mold taking example

For modulo, the numbers (operands and operands) on both sides of% must be integers. The remainder after division is returned.

main()
{
	int a = 5 %2;//Shang 2 Yu 1
	printf("a=%d\n", a);
}

Supplement:

1. In addition to the% operator, several other operators can act on integers and floating-point numbers
2. For the / operator, if both operands are integers, perform integer division. As long as there are floating-point numbers, perform floating-point division.

Shift operator:

< < left shift operator
>>Right shift operator
Note: their operands must be integers, and the bits here are binary bits

1. Shift right operator

<1> Arithmetic shift right: discard the right and fill the original sign bit on the left (the original positive number is filled with a 0, the original negative number is filled with a 1)
<2> Logical shift right: discard on the right and fill 0 on the left
So what kind of shift does the compiler use?
The compiler adopts arithmetic shift, and the code proves that:

main()
{
	int a = -1;
	int b=a >> 1;//Shift right one bit
	printf("%d\n", b);
}

Ask the question: why not the 31st power of negative 2?
(citing brother Peng) "what moves in the memory is the complement, and the official print is the source code." < \ font >
Specific analysis:
1. First, there are three binary representations of integers: original code, inverse code and complement code.
2. The second is that the complement is stored in the memory, so when a shifts, it shifts the complement (for positive integers, the original, inverse and complement are the same)
3. Again, it is the original inverse complement of a (a=-1, negative).
Original: because it is a negative number, write 1 in the highest position
10000000000000000000000000000001
Reverse: (relative to the original code, the sign bit remains unchanged, and other bits are reversed by bit)
1111111111111111111111111111111111110
Complement: (inverse code + 1)
1111111111111111111111111111111111111

2. Shift left operator

Discard on the left and supplement 0 on the right

Supplement:

For shift operators, do not move negative digits, which is not defined in the standard. For example:
int num=10;
num>>-1//error

Bitwise operators:

&  bitwise AND
|  bitwise OR
^  bitwise XOR
Note: their operands must be integers. The bits here are binary bits.

Bitwise AND:

Two numbers (a, b) are binary transformed and compared in the same bit. If one 0 is 0, it is 1 before it is 1. (abbreviation: one false is false, and all true is true)
Code example:

Supplement: there are several code examples for calculating the complement of a number:

main()
{
 int num,i;
 int count=0;
 scanf("%d", &num);
 for (i = 0; i < 32; i++)
 {
 	if ((num>>i)&1==1)
 		count++;
 }
 printf("count=%d\n", count);
}

Bitwise OR:

As long as one is 1, it is 1, and two are 0 at the same time, it is 0. (short note: one true is true, and all false is false)
Code example:

Bitwise XOR

The binary bits corresponding to two numbers (a,b) are 0 if they are the same and 1 if they are different.

Add a test question: do not create temporary variables, exchange the values of 2 int numbers
a=a^b;
b=b^a;
a=b^a;

Assignment operator:

Re assign the value to the variable (note that the assignment operator is a = sign, and judging whether it is equal is two = signs)

Continuous use of operators

a=x=y+1; assign y+1 to X and then assign x to a (this is called the continuous use of assignment operators)

Compound assignor

+=, - =, * =, / =,% =, > > =, < < =, & =, | =, ^ = (these operators can be written as compound effects. Code example:)

int x=10;
x=x+10;
x+=10;//Compound operator
//For the same reason as other operators, this is more concise.

Monocular operator:

What is unary? There is only one operand. What unary operators do we have?
! logical inverse operation (true becomes false, false becomes true < fixed to 1 >)
-  negative sign
+  positive value
&  get address
*  dereference operator
Size of memory space occupied by sizeof   variables (including arrays) (in bytes)
~  bitwise negation of a number
--   front and rear
++  front, rear++
(type)   cast type

Use of sizeof

Example 1:

main()
{
	int a = 10;
	char c = 'r';
	char* p = &c;
	int arr[10] = { 0 };
	printf("%d\n",sizeof a);//Integer 4 bytes, a can omit parentheses
	printf("%d\n",sizeof(int));//The result of calculating the size of a is the same as that of its type. int cannot omit parentheses
	printf("\n");
	printf("%d\n",sizeof(c));//character
	printf("%d\n",sizeof(char));
	printf("\n");
	printf("%d\n",sizeof(p));//The pointer size is 4 or 8
	printf("%d\n",sizeof(char*));
	printf("\n");
	printf("%d\n",sizeof(arr));//The size of the array. There are 10 elements in the array. Each element is an integer, and each integer is 4 bytes, so 4 * 10 = 40
	printf("%d\n",sizeof(int[10]));//int[10] is the type of array (remove the array name from the array)
	printf("\n");
}

result:

Example 2:

main()
{
	short s = 0;
	int a = 10;
	printf("%d\n", sizeof(s = a + 5));//No matter what type A is, as long as it is placed in s, it can only become a short integer. The result is calculated by s, and S is two bytes
	printf("%d\n", s);//S can put down 15, so 0 is output because the expression in sizeof (s=a+5) will not be actually calculated, and the value of s remains unchanged
}

result:

++Use of front and rear

example:

(types): cast types

For example:
int a =(int)3.14;

Relational operator

>
>=
<
<=
==  used to test "equality"
!=   used to test "inequality"

Logical operator

&&  logic and
||  logical or

Distinguishing logic from bitwise

Logic and, logic or concerns whether the number itself is true or false
Bitwise and, bitwise or concerned with the binary sequence of this number

Depth interpretation

The characteristic of logic and is that if the result calculated on the left is false, we don't calculate whatever is on the right. Similarly, the characteristic of logic or is that if the left is true, the right is not counted. Code examples are as follows:

main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++&&++b&&d++;//The result of a + + is 0, and the relationship between & & is that as long as one is 0, whatever is on the right is false, then it will not be executed later, + + b and d + + will not be executed, and a will increase by 1 after use
	printf("a=%d\n b=%d\n c=%d\n d=%d\n", a,b,c,d);
}

The result is:

Conditional operator (also known as ternary operator)

exp1?exp2:exp3
Explanation: if the result of expression 1 is true, the result of expression 2 is the result of the whole expression. If the result of expression 1 is false, the result of expression 3 is the result of the entire expression.

comma expression

A comma separated expression: exp,exp2,exp3
Comma expressions are executed from left to right. The result of the whole expression is the result of the last expression.

Subscript references, function calls, and structure members

1. [] subscript reference operator

Operand: an array name + an index value

2. () function call operator

Accepts one or more operands. The first operand is the function name, and the remaining operands are the parameters passed to the function

3. Visit members of a structure

.   structure, member name
->  structure pointer - > member name

Code example:

//Create a structure type - struct Stu
struct stu
{
	//Member variable
	char name[20];
	int age;
	char id[20];
};
main()
{
	//Using a variable of type struct Stu, a student object s1 is created and initialized
	struct stu s1 = { "Zhang San", 20, "20210910" };
	struct stu* ps = &s1;
	//Structure pointer - > member name
	printf("%s\n", ps->name);//ps is a pointer to an object
	printf("%d\n", ps->age);
	printf("%s\n", ps->id);
	//Structure variable. Member name
	printf("%s\n", s1.name);
	printf("%d\n", s1.age);
	printf("%s\n", s1.id);
}

Expression evaluation

The order in which expressions are evaluated is partly determined by the priority and associativity of operators. Similarly, the operands of some expressions may need to be converted to other types during evaluation.

Implicit type conversion

integral promotion

The integer arithmetic operation of C is always performed at least with the precision of the default integer type.
To achieve this precision, the characters and short integer operands in the expression are converted to normal shaping before use, which is called integer lifting.

Significance of integer promotion

Example 1:

char a,b,c;
a=b+c;
The values of b and c will be promoted to normal shaping, and then the addition operation will be performed.
After the addition operation is completed, the result can be truncated and then stored in a.

main()
{
	char a = 3;
	//00000000000000000000000000000011
	//00000011-a
	char b = 3;
	//01111111-b
	char c = a + b;
	//10000010 is placed in c, the high bit is the sign bit, and the negative number is converted to the original inverse complement (different from the positive number)
	//11111111111111111111111110000010 complement
	//11111111111111111111110000001 - inverse code
	//1000000000000001111110 - original code
	printf("%d\n", c);//-126
}

How to improve the integer?

Integer promotion is promoted according to the sign bit of the data type of the variable

Integer promotion of negative numbers

char c1=-1;
There are only 8 bits in the binary bit (complement) of variable c1:
1111111
Because char is a signed char
Therefore, when shaping and lifting, the high supplementary symbol bit is 1
The results after promotion are:
11111111111111111111111111111111

Integer promotion of positive numbers

char c2=1;
There are only 8 bits in the binary bit (complement) of variable c2:
00000001
Because char is a signed char
Therefore, when shaping and lifting, the high supplementary symbol bit is 0
The results after lifting are as follows:
00000000000000000000000000000001

Unsigned integer lifting, high complement 0

Example 2:

main()
{
	char c = 1;
	printf("%d\n",sizeof(+c));
}

As long as c in example 2 participates in expression operation, integer promotion will occur, so sizeof(+c) is four bytes. The result of the expression is:

Arithmetic conversion

Arithmetic conversion is also an implicit type conversion. If the operands of an operator are of different types, the operation cannot be performed unless one of the operands is converted to the type of the other operand. The following hierarchy is called ordinary arithmetic conversion.
long double
double
float
unsigned long int
long int
unsigned int
int
If the type of an operand is low in the above list (small type), it is first converted to the type of another operand (large type) and then the operation is performed.

Properties of the operator

There are three factors that affect the evaluation of complex expressions.
1. Operator priority
2. Associativity of operators
3. Control evaluation sequence
Which of the two adjacent operators should be executed first? Depends on their priorities. If the two have the same priority, it depends on their combination.

operator precedence

Conclusion: if the expression we write cannot determine the unique calculation path through the properties of the operator, there is a problem with this expression.