C语言操作符

C语言操作符总结：
操作符分为：
1、算术操作符
2、移位操作符
3、位操作符
4、赋值操作符
5、单目操作符
6、关系操作符
7、逻辑操作符
8、条件操作符 逗号表达式
9、下 标引用、函数调用和结构成员
算数操作符:

+ - * / %

• 除了%操作符之外，其他的几个操作符可以作用于整数和浮点数。
• 对于/操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
• %操作符的两个操作数必须为整数。返回的是整除之后的余数。
  移位操作符
  1、<< 左移操作符 左边抛弃，右边补0；
  2、>> 右移操作符
  右移操作符包括两种：

1. 逻辑移位 左边用0填充，右边丢弃
2. 算术移位 左边用原该值的符号位填充，右边丢弃
   警告：移位操作符不能移动负数位，这是标准定义的。
   例如：

int num = 10;
num>>-1;//error

位操作符
分为以下几种：
& //按位与
| //按位或
^ //按位异或
注意：他们的操作数必须是整数。
练习一下：

#include<stdio.h>
int main()
{
int num1=1;
int num2=2;
num1&num2;
num1|num2;
num1^num2;
return 0;

一道变态的面试题：
不能创建临时变量 ，实现两个数的交换。

#include <stdio.h>
int main()
{
int a=10;
int b=20;
a=a^b;
b=a^b;
a=a^b;
printf ("a=%d b=%d\n",a,b);
return 0;
}

练习：
编写代码实现：求一个整数存储在内存的二进制1的个数。
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
int count_one_bits1(int value)
{
int count1 = 0;
int i = 0;
for (i = 0; i<32 ; i++)
{
if (1 == ((value>>i)&1))
{
count1++;
}
}
return count1;
}
int count_one_bits2(int value)
{
int count2 = 0;
while(value)
{
count2++;
value = value&(value-1);
}
return count2;
}
int count_one_bits3(int x)
{
int count3 = 0;
while (x)
{
if (1 == x%2)
{
count3++;
}
x /= 2;
}
return count3;
}

int main()
{
int n = 0;
printf (“请输入一个整数n:”);
scanf ("%d",&n);
count_one_bits1(n);
printf ("%d\n",count_one_bits1(n));
count_one_bits2(n);
printf ("%d\n",count_one_bits2(n));
count_one_bits3(n);
printf ("%d\n",count_one_bits3(n));

system ("pause");
return 0;

}
赋值操作符
赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。
int weight = 120;//体重
weight = 78;//不满意就赋值
double salary = 1000.0;
salary = 20000.0;//使用赋值操作符
赋值操作符可以连续使用，比如：
int a=10;
int x=0;
int y=20;
a=x=y+1;//连续赋值
这样的代码不好

同样的的语意，看看：
x=y+1;
a=x;
这样的写法更加清晰更易于调试。

复合操作符
1.+=
2.*=
3./=
4.%=
5.>>=
6.<<=
7.&=
8.|=
9.^=
这些运算符都可以写成复合的效果。比如：
int x=10;
x = x+10;
x += 10;//复合赋值。
//其他运算符一样的道理。这样写更加简洁。
单目操作符
！逻辑反操作 -负值+正值 &取地址
sizeof操作的类型长度（以字节为单位）~对于一个数的二进制按位取反–前置后置–
++前置后置++
*间接访问操作符（解引用操作符）
（类型）强制类型转换
演示代码：
#include <stdio.h>
int main()
{ int a = -10;
int *p = NULL;
printf("%d\n", !2);
printf("%d\n", !0); a = -a; p = &a;
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof a);//这样写行不行？
printf("%d\n", sizeof int);//这样写行不行？
return 0;
}
sizeof和数组
#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//(2)
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//(4)
}
int main()
{
int arr[10] = {0};
char ch[10] = {0};
printf("%d\n", sizeof(arr));//(1)
printf("%d\n", sizeof(ch));//(3)
test1(arr);
test2(ch);
return 0;
}
++和- -运算符：

    //前置++和-   
     //对于前置的++和--来说： 
        #include <stdio.h>   
         int main()   
          {     
     int a = 10;  
     int x = ++a;  
         //先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。      
      int y = --a;       
     //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;      
       return 0;  
                             } 
      //后置++和- 
        #include <stdio.h> 
     int main() 
     {       
  int a = 10;  
    int x = a++; 
        //先对a先使用，再增加，这样x的值是10；之后a变成11；  
           int y = a--;  
        //先对a先使用，再自减，这样y的值是11；之后a变成10；   
            return 0; 
               }

一个怪诞的程序：

#include <stdio.h>
 int main()
  {  
    int i = 1; 
    int ret = (++i) + (++i) + (++i);    
    printf("%d\n", ret);  
    printf("%d\n", i);  
    return 0; 
  } 
 //尝试在linux 环境gcc编译器，VS2013环境下都执行，看结果。

Linux环境的结果：

vs2013结果:

总结：

1. 说明这个代码本身不是一个好代码。
2. 结果跟表达式的求值顺序有关系。
3. 表达式的求值依赖于运算符的优先级和结合性，但操作符的优先级和结合性又不能确定唯一的计算路 径。
4. 这样的表达式产生的结果是严重依赖于表达式的求值顺序，所以不要写出这样的表达式。
5. 在学习的时候也不要钻牛角尖。

关系操作符
1、>
2、>=
3、<
4、!= 用于测试“不相等”
5、== 用于测试“相等”

警告： 在编程的过程中== 和=不小心写错，导致的错误。
逻辑操作符

||逻辑或
&&逻辑与

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

1&2----->0 
1&&2---->1


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

条件操作符

exp1 ? exp2 : exp3

逗号表达式：

exp1, exp2, exp3, …expN

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

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

1.[ ] 下标引用操作符

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

  int arr[10];//创建数组  
    arr[9] = 10;//实用下标引用操作符。
        [ ]的两个操作数是arr和9.

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

 #include <stdio.h>    
 void test1()  
   {      
 printf("hehe\n");  
  }  
void test2(const char *str) 
{      
printf("%s\n", str);
  }    
  int main()   
 {      
   test1();    //实用（）作为函数调用操作符。     
    test2("hello bit.");//实用（）作为函数调用操作符。   
   return 0; 
  }

3.访问一个结构的成员

. 结构体.成员名 -> 结构体指针->成员名

#include <stdio.h> 
struct Stu
 {    
 char name[10];    
 int age;   
  char sex[5]; 
 double score;
      }；
 
void set_age1(struct Stu stu) 
{   
stu.age = 18;
 } 
 void set_age2(struct Stu* pStu) 
 {  
   pStu->age = 18;//结构成员访问
 }
 int main()
 {   
struct Stu stu;  
 struct Stu* pStu = &stu;//结构成员访问 
  stu.age = 20;//结构成员访问  
set_age1(stu); 
 pStu->age = 20;//结构成员访问
 set_age2(pStu);  
  return 0;
  }

表达式求值

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

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

隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

//实例1
 char a,b,c; 
 ... 
 a = b + c;

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

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

整形提升是按照变量的数据类型的符号位来提升的

//负数的整形提升 
char c1 = -1;
 变量c1的二进制位(补码)中只有8个比特位： 1111111
  因为 char 为有符号的 char 
  所以整形提升的时候，高位补充符号位，即为1 提升之后的结果是： 11111111111111111111111111111111
 
//正数的整形提升
 char c2 = 1; 
 变量c2的二进制位(补码)中只有8个比特位： 00000001
  因为 char 为有符号的 char 
  所以整形提升的时候，高位补充符号位，即为0 提升之后的结果是： 00000000000000000000000000000001
 
//无符号整形提升，高位补0





//实例2
 a = （~a ^ b << 1）>> 1;

对于实例1的结果和使用8位算术运算的结果是一样的，但是实例2就不一样了。
由于存在求补和左移操作，所以8位的精度是不够的。
标准要求进行完整的整型求值，所以对于这类表达式的结果，不会存在歧义。

算术转换

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

long double
 double
 float 
 unsigned long int
  long int 
  unsigned int 
  int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
警告： 但是算术转换要合理，要不然会有一些潜在的问题。

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

操作符的属性
复杂表达式的求值有三个影响的因素。

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序
   两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。