学习笔记 day3-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_46420972/article/details/128209198

1 关于逻辑与逻辑或的短路原则

逻辑与：从左往右计算，有一个表达式结果为0，则整体为0，右边表达式不计算。
逻辑或：从左往右计算，有一个表达式结果为1，则整体为1，右边表达式不计算。
例：
		a=100, b=100
num = a>=100 && ++b:   num=1   a=100   b=101

		a=100,b=100;
num = a>=100 || ++b;     num=1   a=100   b=100

2 如何输入一个以回车结尾的字符串s

方法1：使用gets(s)方法
方法2：使用scanf(“%[^\n]”,s)
方法3：使用循环 按字符输入

3 处理垃圾字符的方法

方法1：使用抑制符   scamf(“%c%*c%*c%c”)
方法2：使用空格隔开，可以处理所有垃圾字符   scanf(“%c %c %c”)
方法3：使用getchar()

垃圾字符：%d 在接收缓冲区中的数据时，空格、回车、Tab 键都只是分隔符，不会被 scanf 当成数据取用。%d 遇到它们就跳过，取下一个数据。但是如果是 %c，那么空格、回车、Tab 键都会被当成数据给 scanf 取用。

4 位运算符

~按位逻辑反     1010->0101
&按位逻辑与     1001&1111->1001       只有同1为1，否则为0
| 按位逻辑或     1010 | 1111->1111       只有同0为0，否则为1
^按位逻辑异或   1101^1011->0110        相同为0，不同为1
<<左移    1001111<<3   -->  1111000
>>右移   10011110>>4   -->  00001001

5 printf函数是一个行缓冲函数，先将内容写道缓冲区，满足一定条件后，才会将内存写入对应的文件或者流中。

刷新缓冲区的条件：
1.	遇到\n会刷新缓冲区
2.	程序结束会刷新缓冲区
3.	缓冲区满也会刷新缓冲区（1024个字节）
4.	手动刷新缓冲区fflush
5.	当标准输入流和标准输出流一方要使用缓冲区时，另一方需要让出缓冲区。

6 有关printf的格式输出参数

%d：32位有符号		#：用于不同进制的前导符
%u：32位无符号		m：设置输出内容宽度
%o：8进出输出		0：设置宽度后，左边空格补0
%x：16进制输出		-：改为左对齐
%f：单精度浮点型		.n：保留小数点后n位
%lf：双精度浮点型
%e：指数输出
%c：字符输出
%s：字符串输出
%%：输出%本身

7 问号表达式

在这里插入图片描述

计算中注意优先级。

8 c语言运算符优先级

在这里插入图片描述

注意：后置++(结合律：从左往右)的优先级要高于前置++和*（从右往左）

9 逗号表达式

语法格式： a = (表达式1，表达式2，表达式3，...,表达式n);
执行顺序：先执行表达式1，再执行表达式2，直到表达式n执行结束，将表达式n的结果作为整个表达式的结果赋值给a (逗号运算符必须使用括号)

10 scanf的用法

%d:有符号整型数据
%f:浮点型数据
%c:字符数据
%s:字符串数据
m：设置输入的宽度，如果输入的内容超过设置的宽度，只会保存设置宽度的内容
*：抑制符，当前带有*的格字符输入的内容不会保存到与之对应的变量中，而是将下一个不带*的格式字符保存到之前的变量中。
# 一 运算符

1.1 算术运算符

双目运算符：操作数为2（运算符的两边各有一个变量）

+ - * / %

单目运算符:操作数为1：（运算符边上只有一个变量）

++:自增，每次自增1 
--:自减，每次自减1

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a = 300,b = 200;
	printf("%d + %d = %d\n",a,b,a+b);
	printf("%d - %d = %d\n",a,b,a-b);
	printf("%d * %d = %d\n",a,b,a*b);
	printf("%d / %d = %d\n",a,b,a/b);
	//printf想要输出%本身，需要再加上一个%
	printf("%d %% %d = %d\n",a,b,a%b);

	float m = 12.64,n = 46.52;	
	printf("%f + %f = %f\n",m,n,m+n);
	printf("%f - %f = %f\n",m,n,m-n);
	printf("%f * %f = %f\n",m,n,m*n);
	printf("%f / %f = %f\n",m,n,m/n);
//取余只能在两个整数之间，浮点型数据不能取余	
	//printf("%f %% %f = %f\n",m,n,m%n);
	
	printf("*************************\n");
	int i = 100,j,k = 200;
	printf("i = %d\n",i);
	i+1;
	//j = i++;   //i = i+1
	//j = ++i;
	printf("j = %d\n",j);

	//j = ++i+ ++i+ ++i;
	printf("i = %d,j = %d\n",i,j);
	j = i++ +(++k);
	printf("i = %d,k = %d,j = %d\n",i,k,j);
	return 0;
}

练习：输入一个三位数，求个位，十位，百位的和

789 --->7 + 8 + 9 = 24
789 / 100 = 7
789 % 10 = 9
789 /10 %10 = 8

1.2 关系运算符

 > >= < <= == !=  用于表示表达式和表达式之间关系的

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a = 10,b = 20,c;
	c = a > b;
	printf("c = %d\n",c);
	c = a < b;
	printf("c = %d\n",c);
//关系运算符只要在控制语句中使用,判断条件是否成立	
	if(a > b)
	{
		printf("a > b\n");
	}
	else
	{
		printf("a <= b\n");
	}
	return 0;
}

1.3 逻辑运算符

！：逻辑反，原本表达式为真变为假，原本表达式为假变为真
&&：逻辑与：两个表达式都为真，才为真，只要有一个为假则整体为假
	a > b && a > c  //a > b 并且 a > c
||：逻辑或：两个表达式有一个为真则整体为真，都为假才为假
	a > b ||a > c  //a > b 或者 a > c
判断一个变量a的值是否在10到20范围内：
    数学：10 <= a <=20
    c语言：a >=10 && a <=20
判断一个变量a的值是否不在10到20的范围内：
    数学：a < 10 或 a > 20
    c语言：a < 10 || a > 20

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a = 100;
	int b = a;
	printf("b = %d\n",b);
	
	b = !a;  //真变假 非0变成0
	printf("b = %d\n",b);

//	int num = a > 100 && ++b;  //短路原则[逻辑与]：从左往右计算，有一个表达式结果为0，则整体为假，右边表达式将不再计算
//	printf("num = %d,b = %d\n",num,b);
	

	int num2 = a >=100 || ++b; //短路原则[逻辑或]：从左往右计算，有一个表达式成立，则整体为真，右边所有表达式将不再计算
	printf("num = %d,b = %d\n",num2,b);
	return 0;
}

1.4 位运算符

~ 位逻辑反 1001 --> 0110
& 位逻辑与  1001 & 1111 ---> 1001,同为1则为1，否则为假
| 位逻辑或  1010 | 1111 ---> 1111,只要有一个为1,则为1，都为0才为0
^ 位逻辑异或 相同为0 ，不同为1 1101 ^ 1011-->0110
<< 左移  1001111 << 3 --->1111000
>> 右移  10011110 >> 4 -->00001001

#include <stdio.h>

int main(int argc, const char *argv[])
{
	unsigned char m = 0x67,n = 0x3b;
	unsigned char k;
//位逻辑反
	k = ~m;
	//m:  0110 0111
	//~m: 1001 1000 = 0x98;
	printf("k = %#x\n",k);
//位逻辑与
	k = m & n;
	//m:    0110 0111
	//n:    0011 1011
	//m & n 0010 0011 = 0x23
	printf("k = %#x\n",k);
	
//位逻辑或
	k = m | n;
	//m:    0110 0111
	//n:    0011 1011
	//m | n 0111 1111 ->0x7f
	printf("k = %#x\n",k);
//位逻辑异或
	k = m ^ n;
	//m:    0110 0111
	//n:    0011 1011
	//m ^ n 0101 1100 -->0x5c
	printf("k = %#x\n",k);
//左移
	k = m << 3;
	//m:     0110 0111
	//m << 3 0011 1000->0x38
	printf("k = %#x\n",k);
//右移
	k = m >> 3;
	//m:     0110 0111
	//m >> 3 0000 1100-->0x0c
	printf("k = %#x\n",k);
	return 0;
}

练习：

unsigned short num = 0
第一步：将1，3，5，7，9置为1
第二步：将2，4，6置为1
第三步: 将1，2，3 置为0
第四步：将11，12，13，14置为1
    0000 0001 0111 1000
    0011 1101 0111 1000
    0011 1101 0111 1000
第五步：将10，13，15置为0
    0011 1101 0111 1000
    0010 1101 0111 1000
    0010 1101 0111 1000

#include <stdio.h>

int main(int argc, const char *argv[])
{
	unsigned short num = 0;
	num = 0x155;
	printf("num = %#x\n",num);
	num = num | 0x17f;
	printf("num = %#x\n",num);
	num = num & 0x178;
	printf("num = %#x\n",num);
	num = num |0x3d78;
	printf("num = %#x\n",num);

	num = num &0x2d78;
	printf("num = %#x\n",num);
	return 0;
}

1.5 赋值运算符和赋值复合运算符

赋值运算符：=
左值 = 右值
注意：左值必须是变量，右值可以是变量也可以是常量
注意事项：
    =:赋值
    ==：判断
赋值复合运算符：a = a + b --->a += b;   a -= 1; //a = a-1
 +=,-=,*= /= %=

1.6 条件运算符—三目运算符

语法格式：
	表达式1？表达式2：表达式3
 运行顺序：先执行表达式1，如果表达式1成立，则执行表达式2，否则执行表达式3.
 相当于if...else语句
 if(表达式1)
 {
     表达式2
 }
else
{
     表达式3
}

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a = 20,b = 30;
	//int k = a > b ? a++ : b++;
	//printf("a = %d,b = %d,k = %d\n",a,b,k);
   // int k = (a = b) ? a++ : b++;
	//printf("a = %d,b = %d,k = %d\n",a,b,k);
    int k = (a = b ? a++ : b++);
	//int temp = a;
	//a = a + 1;
	//return temp; 
	printf("a = %d,b = %d,k = %d\n",a,b,k);
	return 0;
}

1.7 逗号运算符

语法格式：
a = (表达式1，表达式2，表达式3，...,表达式n);
执行顺序：先执行表达式1，再执行表达式2，直到表达式n执行结束，将表达式n的结果作为整个表达式的结果赋值给a
    (逗号运算符必须使用括号)

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a = 10,b = 20,c;
	c = (++a,++b,a = a+b,a++);
	printf("a = %d,b = %d,c = %d\n",a,b,c);
	return 0;
}

1.8 sizeof运算符

主要用于计算数据类型所占内存空间的大小
n = sizeof(数据类型/变量名)   //n保存这个数据类型所占内存的字节数

#include <stdio.h>

int main(int argc, const char *argv[])
{
	char a;
	printf("sizeof(char) = %ld\n",sizeof(a));
	printf("sizeof(char) = %ld\n",sizeof(char));
	printf("sizeof(long) = %ld\n",sizeof(long));  //64位中占8个字节，32位占4个字节
	return 0;
}

1.9运算符的优先级

第1优先级：各种括号，如()、[]等、成员运算符 . ；
第2优先级：所有单目运算符，如++、–、!、~等；
第3优先级：乘法运算符*、除法运算符/、求余运算符%；
第4优先级：加法运算符+、减法运算符-；
第5优先级：移位运算符<<、>>；
第6优先级：大于运算符>、大于等于运算符>=、小于运算符<、小于等于运算符<=；
第7优先级：等于运算符==、不等于运算符!=；
第8优先级：按位与运算符&；
第9优先级：按位异或运算符^；
第10优先级：按位或运算符|；
第11优先级：逻辑与运算符&&；
第12优先级：逻辑或运算符||；
第13优先级：三目条件运算符 ?: ；
第14优先级：各种赋值运算符，如=、+=、-=、*=、/= 等；
第15优先级：逗号运算, 

注意：后置++(结合律：从左往右)的优先级要高于前置++和*（从右往左）  *p++ *++q
原文链接：https://blog.youkuaiyun.com/qq_44605933/article/details/104235009

练习：输入三个数，按照从小到大排序

int a = 10,b = 5,c = 8;

....

a = 5,b = 8,c = 10;

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a,b,c;
	printf("请输入三个数：\n");
	scanf("%d %d %d",&a,&b,&c);
	printf("排序前：a = %d,b = %d,c = %d\n",a,b,c);

	int temp;
	if(a > b)
	{
		temp = a;
		a = b;
		b = temp;
	}
	if(a > c)
	{
		temp = a;
		a = c;
		c = temp;
	}
	if(b > c)
	{
		temp = b;
		b = c;
		c = temp;
	}
	printf("排序后：a = %d,b = %d,c = %d\n",a,b,c);
	return 0;
}

二输入输出函数

2.1 getchar/putchar

#include <stdio.h>
int getchar(void);从终端获取一个字符
int putchar(int c);向终端输出一个字符

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int ch;
	//ch = getchar();
	//printf("ch = %c,%d\n",ch,ch);
	int a,b,c;
	a = getchar();
	b = getchar();
	c = getchar();
	printf("a = %c %d\n",a,a);
	printf("b = %c %d\n",b,b);
	printf("c = %c %d\n",c,c);
	return 0;
}

#include <stdio.h>

int main(int argc, const char *argv[])
{
	//参数为字符
	putchar('w');
	putchar('\n');
	
	//参数为字符的ascii值
	putchar(97);
	putchar(10);

	//参数为变量
	int a = 'c';
	putchar(a);
	putchar(10);
	return 0;
}

2.2 gets/puts

#include <stdio.h>
char *gets(char *s);  //从终端获取一个字符串
int puts(const char *s);  //向终端输出一个字符串

#include <stdio.h>

int main(int argc, const char *argv[])
{
	puts("helloworld");

	char s[32] = "helloworld";
	puts(s);

	char buf[32];
	gets(buf);
	puts(buf);

	puts("hello\0world");
	puts("");
	return 0;
}

2.3 printf()/scanf()

2.3.1 printf()

printf函数是一个行缓冲函数，先将内容写到缓冲区，满足一定条件后，才会将内存写入对应的文件或者流中。
刷新缓冲区的条件：
    1.遇到\n会刷新缓冲区
    2.程序结束会刷新缓冲区
    3.缓冲区满也会刷新缓冲区（1024个字节）
    4.手动刷新缓冲区fflush
    5.当标准输入流和标准输出流一方要使用缓冲区时，另一方需要让出缓冲区。

#include <stdio.h>

int main(int argc, const char *argv[])
{
	for(int i = 0 ; i < 1024;i++)  //缓冲区满会刷新缓冲区
	{
		printf("i");
	}
	//fflush(stdout); //手动刷新缓冲区
	int c;
	scanf("%d",&c);  //当一方要使用的时候，另一方需要让出缓冲区
	//printf("helloworld");
	while(1);
	return 0;
}

#include <stdio.h>
int printf(const char *format, ...);
功能：向终端按照格式输出字符串
参数：
    format：带格式要输出的内容
    	普通字符：原样输出
    格式说明：%[修饰符]格式字符，用于指定输出格式
    	%d 32位有符号
    	%ld 64位有符号
    	%u 32位无符号
    	%o 8进制输出
    	%x 16进制输出
    	%f 单精度浮点型
    	%lf 双精度浮点型
    	%e 指数输出
    	%c 字符输出
    	%s 字符串输出
    	%% 输出%本身
    附加格式字符：
    	#:用于不同进制的前导符
    	l:用于long或者double或者sizeof类型的数据
         m: 设置输出的内容的宽度
         0：当设置宽度后，默认右对齐，左边空格补0
         -：将右对齐改成左对齐
         .n:保留小数点后n位
    ...:可变参数，可以有，可以没有
返回值：输出的字节数

实例：

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int num = 356;
	//设置输出的宽度为5
	printf("%5d%5d%5d\n",num,num,num);
	//0：右对齐补0

	printf("%05d%05d%05d\n",num,num,num);
	//：将右对齐改成左对齐
	//:0不能用于左对齐的形式	
	printf("%-5d%-5d%-5d\n",num,num,num);

	float f = 45.456789451321;
	printf("f = %f\n",f);
	//.15:保留小数点后15位
	printf("f = %.15f\n",f); 
	return 0;
}