[C++知识库]操作符、关键字，及define

操作符、关键字，及#define定义

操作符

算术运算符

? + - * / %

% 取模（求两个整数的余数） 例：5 % 2 = 1

移位操作符

? << >>

对二进制进行移位操作

如：<< 左移操作符

int a = 1;
//a在内存中存储形式为 00000000000000000000000000000001
int b = a << 2;
// 二进制向左移动2位,最右侧补零,同时把最左侧溢出的两位删除。
//a的存储形式为 00000000000000000000000000000001 （转化为十进制值为1）
//b的存储形式为 00000000000000000000000000000100 （转化为十进制值为4）

位操作符

& 按位与

^ 按位异或

| 按位或

int a = 3;	// 011
int b = 5;	// 101
int c = a&b;// 001 按位与： 需要对应二进制位都为1才能出1
int d = a|b;// 111 按位或： 只要对应二进制位有一个为1就出1
int e = a^b;// 110 按位异或：对应二进制位相同出0，相异出1

赋值操作符

• = 等号右边的值赋给等号左边的变量 （ == 判断左右两边是否相等，相等为真，不等为假）

• 复合赋值符：*+= -= = /= <<= >>= &= |= ^=

  += a = a+1; 与 a += 1;完全等价

  -= a = a-1; 与 a -= 1;完全等价

  ……

单目操作符

• ! 逻辑反操作 ：C语言中非0为真，0为假，逻辑反操作就是将真假颠倒。

int a = 3;
int b = -2;
int c = 0;
int d = !a;//d=0;
int e = !b;//b=0;
int f = !c;//f=1;

• - 取负值

• + 取正值

• & 取地址

• sizeof 操作数的类型长度（以字节为单位）

int main()
{
	//sizeof是一个操作符,"不是函数",用来计算类型\变量的大小
	int a = 10;
	printf("%d\n", sizeof(a));//计算变量a的大小
    printf("%d\n", sizeof a);//计算变量a的大小，可将括号省略
    printf("%d\n", sizeof(int));//计算每个int类型数据的大小，不能省略括号
    int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));//计算的是数组的总大小，单位是字节
	int sz = sizeof(arr) / sizeof(arr[0]);//计算数组中元素的个数
	return 0;
}

• ~ 对一个数的二进制按位取反

int main()
{
	int a = 1; //a的二进制原码表示为：00000000000000000000000000000001
	int b = ~a;//b的二进制原码表示为：11111111111111111111111111111110
	printf("%d", b);//-2
	return 0;
}

• – 前置、后置–

	int a = 10;
	int b = a--;//后置--，先使用，再--

	printf("%d\n", b);//10
	printf("%d\n", a);//9

	int b = ++a;//前置-- , 先--，后使用

	printf("%d\n", b);//9
	printf("%d\n", a);//9

• ++ 前置、后置++

	int a = 10;
	int b = a++;//后置++，先使用，再++

	printf("%d\n", b);//10
	printf("%d\n", a);//11

	int b = ++a;//前置++ , 先++，后使用

	printf("%d\n", b);//11
	printf("%d\n", a);//11

• * 间接访问操作符(解引用操作符)

• (类型) 强制类型转换

int main()
{
	//强制类型转换
	int a = (int)3.14;
	printf("%d\n", a);//3
    float b = 5/4;
    float c = (float)5/4;
    printf("b=%f,c=%f",b,c);//b=1.000000,c=1.250000
	return 0;
}

逻辑操作符

• && 逻辑与 （只有两侧全部为真时出1，否则出0）

  //c语言中规定只有0为假，其余非零数字均为真
  	int a = 1;
  	int b = 2;
  	int c = 0;
  	int d = 0;
  	int e = a && b;
  	int f = a && c;
  	int g = c && d;
  	printf("e=%d,f=%d,g=%d", e,f,g);//e=1,f=0,g=0
  

• || 逻辑或 (两侧至少有一个为真时出1，否则出0)

条件操作符

格式：exp1?exp2 : exp3 作用：若exp1为真，执行语句exp2；否则执行语句exp3

int main()
{
	int a = 0;
	int b = 3;
	int max = 0;
	max = a > b ? a : b;
    //与下面语句表达意义相同
    /*if (a > b)
		max = a;
	else
		max = b;*/
	printf("%d\n", max);//3
	return 0;
}

逗号表达式

格式：exp1, exp2, exp3, …expN 作用：逗号表达式，是从左向右依次计算的，整个表达式的结果是最后一个表达式的结果

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

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

• [] 下标引用操作符

  int main()
  {
  	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  	printf("%d\n", arr[5]);
  	return 0;
  }
  

• () 函数调用操作符：调用函数的时候，函数名后边的（）就是函数调用操作符

• .

• ->

关键字

auto  break   case  char  const   continue  default  do   double else  enum   
extern float  for   goto  if   int   long  register    return   short  signed
 sizeof   static struct  switch  typedef union  unsigned   void  volatile  while

typedef

typedef 顾名思义是类型定义，这里应该理解为类型重命名。

//将unsigned int 重命名为uint, 所以uint也是一个类型名 
typedef unsigned int uint;
intmain()
{
    //观察num1和num2,这两个变量的类型是一样的
    unsigned int num1 = 0;
    uint num2 = 0;
    return0;
}

static

• 修饰局部变量

//代码1
#include <stdio.h>  
void test()
{
	int i = 0;  
    i++;
	printf("%d ", i);
}
int main()
{
	int i = 0;  for(i=0; i<5; i++)
	{
		test();
	}
	return 0;
}
//执行结果为输出11111

//代码2
#include <stdio.h> 
void test()
{
    static int i = 0;  
    i++;//static修饰局部变量  
	printf("%d ", i);
}
int main()
{
	int i = 0;  for(i=0; i<5; i++)
	{
		test();
	}
	return 0;
}
//执行结果为输出12345

对比代码1和代码2的效果理解static修饰局部变量的意义。

结论：static修饰局部变量改变了变量的生命周期，让静态局部变量出了作用域依然存在，到程序结束， 生命周期才结束。

• 修饰全局变量

//代码1
//add.c
int g_val = 2018;
//test.c 
int main()
{
    extern g_val;//声明外部符号
    printf("%d\n", g_val);  return 0;
}
//执行结果为输出2018

//代码2
//add.c
static int g_val = 2018;
//test.c  
int main()
{
    extern g_val;//声明外部符号
	printf("%d\n", g_val);  
    return 0;
}
//无法执行，报错显示g_val是无法解析的外部符号

代码1正常，代码2在编译的时候会出现连接性错误。

结论：一个全局变量被static修饰，使得这个全局变量只能在本源文件内使用， 不能在其他源文件内使用。

• 修饰函数

//代码1
//add.c
int Add(int x, int y)
{
	return x+y;
}
//test.c  
int main()
{
    extern int Add(int,int);
	printf("%d\n", Add(2, 3));
	return 0;
}
//执行结果为输出5

//代码2
//add.c
static int Add(int x, int y)
{
	return x+y;
}
//test.c  
int main()
{
    extern int Add(int,int);
	printf("%d\n", Add(2, 3));
	return 0;
}
无法执行，报错显示Add是无法解析的外部符号

代码1正常，代码2在编译的时候会出现连接性错误.

结论：一个函数被static修饰，使得这个函数只能在本源文件内使用，不能在其他源文件内使用。

register

作用：建议将变量定义为寄存器变量，以提高该变量读取速度

register int a = 10;//建议将变量a定义成寄存器变量，但最终由编译器决定是否采纳建议

#define定义常量和宏

#define定义标识符常量

//define定义符号
#define MAX 1000
int main()
{
	printf("%d\n", MAX);
	return 0;
}

#define定义宏

//define 定义宏
#define ADD(X,Y) (X+Y)
//与之具有相同作用的函数表达
/* int ADD(int X,int Y)
{
	return X+Y;
}*/
//比较可知，宏定义具有代码简洁，不用考虑参数类型的优点；
int main()
{
	printf("%d\n", 4*ADD(2, 3));
	return 0;
}