c++基础语法规则

1，c++存储类：定义函数或者变量的生命周期

auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。

register 存储类用于定义存储在寄存器中而不是 RAM （内存）中的局部变量，寄存器是cpu中的相关部件，具体干啥是不明。

static 存储类指示编译器在程序的生命周期内保持局部变量的存在(就是cpp的整个生命进程内)，当全局变量用也是可以的。而不需要在每次它进入和离开作用域时进行创建和销毁。这个比较常用，看个实例吧

#include <iostream>

// 函数声明

void func(void);

static int count = ; /* 全局变量 */

int main()

{

    while(count--)

    {

       func();

    }

    return ;

}

// 函数定义

void func( void )

{

    static int i = ; // 函数每次被调用都会声明局部静态变量为5，但是这并不管用，第一次调用的时候确实为5，第二次的时候就成了6，第三次7，，，如果去掉static，那i就每次都变成5了

    i++;

    std::cout << "变量 i 为 " << i ;

    std::cout << " , 变量 count 为 " << count << std::endl;

}

有关静态全局变量，总结起来有三个好处：

仅对本文件内有效；类似全局变量但是变量属于函数本身，不会随着函数结束而被销毁；仅仅第一次调用的时候初始化，往后再调用就跳过。具体解释看教程：https://blog.csdn.net/majianfei1023/article/details/45290467

extern存储类就是调用前一个文件里的全局变量，省的自己去定义了，或者自己无法初始化，所以‘继承’一个过来。

实例：

/*first file:hello.cpp*/

#include <iostream>

int count ;

extern void write_extern();

int main()

{

   count = ;

   write_extern();

}

/*second file:hello2.cpp*/

#include <iostream>

extern int count;

void write_extern(void)

{

   std::cout << "Count is " << count << std::endl;

}

/*g++ hello.cpp hello2.cpp -o write

bb一句，原来c++中两个文件可以放到一块编译，编译完了就是一个文件；尤其是两个看起来没啥关系的文件*/

mutable 说明符仅适用于类的对象，不知所以，留后。

thread_local存储类，使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。变量在创建线程时创建，并在销毁线程时销毁。每个线程都有其自己的变量副本。

2，运算符

算数运算符：假设b为20，a为10

运算符	描述	实例
+	把两个操作数相加	A + B 将得到 30
-	从第一个操作数中减去第二个操作数	A - B 将得到 -10
*	把两个操作数相乘	A * B 将得到 200
/	分子除以分母	B / A 将得到 2，地板除，21/10=2
%	取模运算符，整除后的余数	B % A 将得到 0
++	自增运算符，整数值增加 1	A++ 将得到 11
--	自减运算符，整数值减少 1	A-- 将得到 9

关系运算符：

假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 不为真。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 不为真。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 不为真。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

逻辑运算符：

假设变量 A 的值为 1，变量 B 的值为 0，则：

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
\|\|	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A \|\| B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

位运算符：

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

&约等于and，|约等于或，^不同为真

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100 得到十进制12

A|B = 0011 1101 得到61

A^B = 0011 0001 得到49

~A = 1100 0011 按位取反，得到-61

运算符	描述	实例
&	如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。	(A & B) 将得到 12，即为 0000 1100
\|	如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。	(A \| B) 将得到 61，即为 0011 1101
^	如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。	(A ^ B) 将得到 49，即为 0011 0001
~	二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<	二进制左移运算符。左操作数的值向左移动右操作数指定的位数。	A << 2 将得到 240，即为 1111 0000
>>	二进制右移运算符。左操作数的值向右移动右操作数指定的位数。	A >> 2 将得到 15，即为 0000 1111

赋值运算符

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C = A 相当于 C = C A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
\|=	按位或且赋值运算符	C \|= 2 等同于 C = C \| 2

其他运算符：

运算符	描述
sizeof	sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。
Condition ? X : Y	条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。
,	逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。
.（点）和 ->（箭头）	成员运算符用于引用类、结构和共用体的成员。
Cast	强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。
&	指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。
*	指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。

运算优先级

类别	运算符	结合性
后缀	() [] -> . ++ - -	从左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	从右到左
乘除	* / %	从左到右
加减	+ -	从左到右
移位	<< >>	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
位与 AND	&	从左到右
位异或 XOR	^	从左到右
位或 OR	\|	从左到右
逻辑与 AND	&&	从左到右
逻辑或 OR	\|\|	从左到右
条件	?:	从右到左
赋值	= += -= *= /= %=>>= <<= &= ^= \|=	从右到左
逗号	,	从左到右

3，循环

while循环和do...while循环：小心死循环

#include <iostream>

using namespace std;

int main ()

{

   // 局部变量声明

   int a = ;

   // while 循环执行

   while( a <  )

   {

       cout << "a 的值：" << a << endl;

       a++;

   }

   return ;

}

do...while：

#include <iostream>

using namespace std;

int main ()

{

   // 局部变量声明

   int a = ;

   // do 循环执行

   do

   {

       cout << "a 的值：" << a << endl;

       a = a + ;

   }while( a <  );

   return ;

}

for循环：和js，php差不多

#include <iostream>

using namespace std;

int main ()

{

   //for 循环执行完了以后会调到紧跟着for循环的语句上去执行

    for( int a = ; a < ; a = a +  )

   {

       cout << "a 的值：" << a << endl;

   }

   return ;

}

嵌套循环：2到100的质数

#include <iostream>

using namespace std;

int main ()

{

    int i, j;

    for(i=; i<; i++) {    //i是2-100的数

        for(j=; j <= (i/j); j++) {    //j是i的除数,而且j只需要比i/j小就行了，这样可以减少循环次数

            if(!(i%j)) {    //可以整除说明有因数

                break; // 如果找到，则不是质数

            }

        }

        if(j > (i/j)) {    //此处不好描述，我们只需要知道当i=11，j=2时候j大于5就不用继续找比5大的因数了，因为木有了

            cout << i << " 是质数 \n";

        }

    }

    return ;

}

4，判断

if...else...实例：

#include <iostream>

using namespace std;

int main ()

{

   // 局部变量声明

   int a = 100;

   // 检查布尔条件

   if( a < 20 )

   {

       // 如果条件为真，则输出下面的语句

       cout << "a 小于 20" << endl;

   }

   else

   {

       // 如果条件为假，则输出下面的语句

       cout << "a 大于 20" << endl;

   }

   cout << "a 的值是 " << a << endl;

   return 0;

}

swich:

#include <iostream>

using namespace std;

int main ()

{

   // 局部变量声明

   char grade = 'D';

   switch(grade)    //以grade作为判断依据

   {

   case 'A' :

      cout << "很棒！" << endl;

      break;

   case 'B' :    //此处的意思是B和C都输出‘做的好’

   case 'C' :

      cout << "做得好" << endl;

      break;

   case 'D' :

      cout << "您通过了" << endl;

      break;

   case 'F' :

      cout << "最好再试一下" << endl;

      break;

   default :

      cout << "无效的成绩" << endl;

   }

   cout << "您的成绩是 " << grade << endl;

   return 0;

}

三元运算符：

if(y < ){

   var = ;

}else{

   var = ;

}

写成以下语句：

var = (y < ) ?  : ;

//如果y<10那就让var=30,否则等于40

5，函数

主函数main(),每个c++程序都有至少一个主函数main

自定义函数：

返回类型    函数名称（ 参数类型 参数）

{

    函数主体

}

自定义函数实例：

#include <iostream>

using namespace std;

// 函数声明，this is necessary !

int max(int num1, int num2);

int main ()

{

   // 局部变量声明

   int a = ;

   int b = ;

   int ret;

   // 调用函数来获取最大值

   ret = max(a, b);

   cout << "Max value is : " << ret << endl;

   return ;

}

// 函数返回两个数中较大的那个数

int max(int num1, int num2)

{

   // 局部变量声明

   int result;

   if (num1 > num2)

      result = num1;

   else

      result = num2;

   return result;

}

函数三种参数调用方式：重点

1，传值调用：（默认）把变量的实际值赋值给形参

#include <iostream>

using namespace std;

// 函数声明

int max(int num1);    //注意，此处不提前写函数声明会报错，

int main ()

{

   // 局部变量声明

   int a = ;

   int x;

   cout <<"original a is:" << a <<endl;    //原来的a是100

   x = max(a);

   cout << "new value is : " << a<< endl;    //后来的a仍旧是100

   return ;

}

// 函数返回两个数中较大的那个数

int max(int num1)

{

    int result=num1++;

    return result;

}

2，指针调用：把变量的地址赋值给形参

#include <iostream>

using namespace std;

// 函数声明

void swap(int *x, int *y);    //星号大约是表示参数为指针类型

int main ()

{

   // 局部变量声明

   int a = ;

   int b = ;

   cout << "交换前，a 的值：" << a << endl;

   cout << "交换前，b 的值：" << b << endl;

   /* 调用函数来交换值

    * &a 表示指向 a 的指针，即变量 a 的地址

    * &b 表示指向 b 的指针，即变量 b 的地址

    */

   swap(&a, &b);

   cout << "交换后，a 的值：" << a << endl;

   cout << "交换后，b 的值：" << b << endl;

   return ;

}
//一开始a=100，b=200,后来a为200,1为100

// 函数定义

void swap(int *x, int *y)

{

   int temp;

   temp = *x;    /* 保存地址 x 的值 */

   *x = *y;        /* 把 y 赋值给 x */

   *y = temp;    /* 把 x 赋值给 y */

   return;

}

3，引用调用：把变量的引用的地址赋值给形参

#include <iostream>

using namespace std;

// 函数声明

void swap(int &x, int &y);    //引用用&符号来表示

 //我理解的引用就是，把a的引用赋值给swap的形参，因为引用指向的就是原存储地址，所以，引用调用实际上也会改变原数据的大小

int main ()

{

   // 局部变量声明

   int a = ;

   int b = ;

   cout << "交换前，a 的值：" << a << endl;    //100 200

   cout << "交换前，b 的值：" << b << endl;

   /* 调用函数来交换值 */

   swap(a, b);

   cout << "交换后，a 的值：" << a << endl;

   cout << "交换后，b 的值：" << b << endl;    //200 100

   return ;

}

// 函数定义

void swap(int &x, int &y)

{

   int temp;

   temp = x; /* 保存地址 x 的值 */

   x = y;    /* 把 y 赋值给 x */

   y = temp; /* 把 x 赋值给 y  */

   return;

}

为函数设置默认值

#include <iostream>

using namespace std;

int sum(int a, int b=)    //设置默认的参数b为20

{

    int result;

    result=a+b;

    return(result);

}

int main()

{

    int c=;

    int result;

    result=sum(c);    //a参数是传进去的值，b参数采用默认

    cout<<result<<endl;

    return  ;

}

lambda匿名函数

这是什么鬼，看了半天也不能理解

用的时候再看的链接