p20 c语言操作符详解(2)

int main(){
    int a=0;
    char b='w';
    int arr[10]={0};
    printf("%d\n",sizeof(a));
    printf("%d\n",sizeof(int));
    printf("%d\n",sizeof(b));
    printf("%d\n",sizeof(char));
    printf("%d\n",sizeof(arr));
    printf("%d\n",sizeof(int[10]));
}

int main(){
	short s=0;
	int a=10;
	printf("%d\n",sizeof(s=a+5));
	printf("%d\n",s);
}

sizeof()里面的数不参与运算

int main(){
    int a=0;
    //~按（2进制）位取反
    //00000000000000000000000-补码
    //11111111111111111111110-反码
    //10000000000000000000001-原码
    //-1
    printf("%d\n",~a);
    return 0;
}

int main(){
    int a=11;
    a=a|(1<<2);
    printf("%d\n",a);

    a=a&(~(1<<2));
    printf("%d\n",a);
}

得出结果：15  11

int main(){
    int a=10;
    printf("%d\n",++a);//前置++，先++，后使用
    printf("%d\n",a++);

return 0；
}

11 11

int main(){
    int a=(int)3.14;//强制转换
    printf("%d",a);
    return 0;
}

3

void test1(int arr[])
{
	printf("%d\n",sizeof(arr));
}
void test2(char ch[])
{
	printf("%d\n",sizeof(ch));
}
int main(){
	int arr[10]={0};
	char ch[10]={0};
	printf("%d\n",sizeof(arr));//
	printf("%d\n",sizeof(ch));
	test1(arr);
	test2(ch);
	return 0;
}

关系操作符

>

>=

<

<=

!=        用于测试“不相等”

==       用于测试“相等”

这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。

警告：再编程的过程中==和=不小心写错，导致的错误

逻辑操作符

逻辑操作符有哪些：

&&        逻辑与

||          逻辑或

区分逻辑与和按位与区分逻辑或与按位与

1&2---->0

1&&2--->1

1|2-------->3

1||2--------->1

逻辑与和或的特点：

360笔试题

int main()
{
	int a=3;
	int b=5;
	int c=a&&b;
	printf("%d\n",c);
	return 0;
}

结果：1

int main()
{
    int a=3;
    int b=5;
    int c=a||b;
    printf("%d\n",c);
    return 0;
}

结果：1

int main()
{
    int a=0;
    int b=0;
    int c=a||b;
    printf("%d\n",c);
    return 0;
}

结果：0

int main(){
	int i=0,a=0,b=2,c=3,d=4;
	i=a++&&++b&&d++;
	printf("a=%d\n b=%d\n c=%d\n d=%d\n ",a,b,c,d);
	//
	return 0;
}

因为a=0&&b&&c&&d 都是0，所以a自增1，最后的结果是1,2,3,4

把a=0改为a=1

int main(){
    int i=0,a=1,b=2,c=3,d=4;
    i=a++&&++b&&d++;
    printf("a=%d\n b=%d\n c=%d\n d=%d\n ",a,b,c,d);
    //
    return 0;
}

其结果是

改为或的时候

int main(){
    int i=0,a=1,b=2,c=3,d=4;
    i=a++||++b||d++;
    printf("a=%d\n b=%d\n c=%d\n d=%d\n ",a,b,c,d);
    //
    return 0;
}

只算a，后面的不变

条件操作符

exp1?exp2:exp3

他就类似于以下的if ....else 语句

if(exp1)

exp2

else

exp3

int main(){
    int a=0;
    int b=0;
    if(a>5)
        b=3;
    else
        b=-3;
    b=(a>5?3:-3);

printf("%d\n",b);

    return 0;
}

int main(){
	int a=10;
	int b=20;
	int max=0;
	if(a>b)
		max=a;
	else
		max=b;
	max=(a>b?a:b);
	printf("max=%d \n",max);
	
	return 0;
}

\

逗号表达式

exp1,exp2,exp3,...expN

逗号表达式，就是用逗号隔开的多个表达式。逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

int main(){
    int a=1;
    int b=2;
    int c=(a>b,a=b+10,a,b=a+1);//逗号表达式
    printf("%d \n",c);
    return 0;
}

结果是13

if(a=b+1,c=a/2,d>0)

//代码3

a=get_val();

count_val(a);

while(a>0)

{

        //业务处理

        //a=get_val();

        count_val(a);

}

如果使用逗号表达式，改写；

while(a=get_val(),count_val(a),a>0)

{

//业务处理

}

下标引用、函数调用和结构成员

1.[ ]下标引用操作符

操作数：一个数组名+一个索引值

int arr[10];//创建数组

arr[9]=10;//实用下标引用操作符 

[ ]的两个操作数是arr和9

int main(){
    int a[10]={0};
    a[4]=10;
    
    return 0;
}

2.（）函数调用操作符 接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

int get_max(int x,int y)
{
    return x>y?x:y;
}
int main(){
    int a=10;
    int b=20;
    //调用函数的时候（）就是函数调用操作符
    int max=get_max(a,b);
    printf("max=%d\n",max);
    return 0;
}

struct Stu
{
	char name[20];
	int age;
	char id[20];
};
int main(){
	int a=10;
	//实用struct Stu这个类型创建了一个学生对象s1,并初始化
	struct Stu s1={"张三",20,"2019010305"};
	printf("%s\n",s1.name);
	printf("%s\n",s1.age);
	printf("%s\n",s1.id);
	//结构体变量，成员名
	return 0;
	}

//学生
//int flaot
//创建一个结构体类型 -struct Stu
struct Stu
{
	char name[20];
	int age;
	char id[20];
};
int main(){
	//实用struct Stu这个类型创建了一个学生对象s1,并初始化
	struct Stu s1={"张三",20,"2019010305"};
	struct Stu *ps=&s1;
	printf("%s\n",ps->name);
	printf("%s\n",ps->age);
	//结构体指针->成员名

	//printf("%s\n",(*ps).name);
	//printf("%s\n",(*ps).age);
	//printf("%s\n",s1.id);
	//结构体变量，成员名
	return 0;
	}

 表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定

同样，有些表达式的操作数在求值的过程中肯呢个需要转换其他类型。

隐式类型转换

c的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

整型提升的意义：

int main(){
    char a=3;
    //000000000000000000000000000000011
    //000000011 -a
    //
    char b=127;
    //000000000000000000000000000111111
    //a如何与b相加
    //000000000000000000000000000000011
    //000000000000000000000000000111111
    //000000000000000000000000010000010
    //
    char c=a+b;
    //10000010-c
    //11111111111111000010-补码
    //11111111111111000001-反码
    //10000000000001111110-原码
    //126
    printf("%d\n",c);
    return 0;
}

结果是-126

表达式的整型运算要在cpu的相应运算期器件内执行，cpu内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是cpu的通用寄存器的长度。

因此，即使两个char类型的相加，在cpu执行时实际上也要先转换为cpu内整型操作数的标准长度。

通用cpu(general-purpose cpu)是满意直接实现两个8比特字节直接相加运算(虽然机器指令中冷呢个有这种字节相加指令)。所以 ，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int ，然后才能送入cpu去 执行运算。

//示例1

char a,b,c;

a=b+c;

b和c的值被提升为普通整型，然后再执行加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

int main(){
	char a=0xb6;
	short b=0xb600;
	int c=0xb6000000;
	if(a==0xb6)
		printf("a");
	if(b==0xb600)
		printf("b");
	if(c==0xb6000000)
		printf("c ");
	return 0;
}

这里只打印C

c只要参与表达式运算，就会发生整型提升，表达式+C就会发生提升，所以，sizeof(+c)是4个字节

表达式-c也会发生整型提升，所以sizeof(-c)是4个字节，但是sizeof(c)就是1个字节

int main(){
	char c=1;
	printf("%u\n",sizeof(c));
	printf("%u\n",sizeof(+c));
	printf("%u\n",sizeof(!c));
	return 0;
}

算数转换

如果某个操作符的各个操作属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算数转换。

long double

double

float

unsigned long int

long int

unsigned int

int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另一个操作数的类型后执行运算。

警告：但是算数转换要合理，要不然会有一些潜在的问题。

float f=3.14;

int num=f;//隐式转换，会有精度丢失。

操作符的属性

复杂表达式的求值有三个影响的因素。

1.操作符的优先级

2.操作符的结合性

是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级，如果两者的优先级相同，取决于他们的结合性，操作符优先级。

一些问题表达式

//表达式的求值部分由操作符的优先级决定。

//表达式1

a*b+c*d+e*f

注释：代码1在计算的时候，由于比+的优先级高，只能保证，的计算是比+早，但是优先级并不能决定第三个*比第一个+早执行。

所以表达式的计算机顺序就可能是：

a*b

c*d

a*b+c*d

e*f

a*b+c*d+e*f

或者：

a*b

c*d

e*f

隐式类型转换

C的整型算术运算总是至少以缺省类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

整型提升的意义：

表达式的整型运算要在CPU的响应运算器件内执行，CPU内整型运算器(ALU)的操作数字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU(heneral-purpose CPU)是难以直接实现两个8比特字节直接相加运算(虽然机器指令中肯呢个有这种字节相加指令)。所以，表达式中各长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能松日CPU去执行运算。

//实例1

char  a,b,c;

a=b+c;

b和c的值被提升为普通整型，然后早执行加法运算。

加法运算完成后，结果江北阶段，然后再存储于a中。

//表达式2

C+ --C;

注释：同上 ，操作符的优先级只能决定自减--的运算在+的运算的前面，但是我们并没有办法得知，+操作符的做操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

//代码3

int main()

{

        int i=10;

        i=i-- - --i*(i=-3)*i++ + ++i;

        printf("i=%d\n",i);

        return 0;

} 

这个代码在不同编译器上的结果不一样，我的是VC6.0++

int fun()
{
	static int count =1;
	return ++count;
}
int main()
{
	int answer;
	answer=fun()-fun()*fun();
	printf("%d\n",answer);//输出多少；
	return 0;
}

结果是-10.

这是个问题代码，你不知道调用的先后顺序

int main()
{
    int i=1;
    int a=(++i)+(++i)+(++i);
    printf("a=%d",a);
    return 0;
}

这个也是含糊不清，在不同的编译器上，其结果也是不一样的。

我这里是10

linux系统下，也是10