c++基础语法规则

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

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

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

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

#include <iostream>
 
// 函数声明 
void func(void);
 
static int count = 10; /* 全局变量 */
 
int main()
{
    while(count--)
    {
       func();
    }
    return 0;
}
// 函数定义
void func( void )
{
    static int i = 5; // 函数每次被调用都会声明局部静态变量为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 = 5;
   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 = 10;
   // while 循环执行
   while( a < 20 )
   {
       cout << "a 的值：" << a << endl;
       a++;
   }
   return 0;
}

do...while：

#include <iostream>
using namespace std;
int main ()
{
   // 局部变量声明
   int a = 10;
   // do 循环执行
   do
   {
       cout << "a 的值：" << a << endl;
       a = a + 1;
   }while( a < 20 );
   return 0;
}

for循环：和js，php差不多

#include <iostream>
using namespace std;
 
int main ()
{
   //for 循环执行完了以后会调到紧跟着for循环的语句上去执行
    for( int a = 10; a < 20; a = a + 1 )
   {
       cout << "a 的值：" << a << endl;
   }
 
   return 0;
}

嵌套循环：2到100的质数

#include <iostream>
using namespace std;
 
int main ()
{
    int i, j;
    for(i=2; i<100; i++) {    //i是2-100的数
        for(j=2; 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 0;
}

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 < 10){ 
   var = 30;
}else{
   var = 40;
}
写成以下语句：
var = (y < 10) ? 30 : 40;
//如果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 = 100;
   int b = 200;
   int ret;
 
   // 调用函数来获取最大值
   ret = max(a, b);
 
   cout << "Max value is : " << ret << endl;
 
   return 0;
}
 
// 函数返回两个数中较大的那个数
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 = 100;
   int x;
   cout <<"original a is:" << a <<endl;    //原来的a是100
   x = max(a);

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

// 函数返回两个数中较大的那个数
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 = 100;
   int b = 200;
 
   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 0;
}
//一开始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 = 100;
   int b = 200;
 
   cout << "交换前，a 的值：" << a << endl;    //100 200
   cout << "交换前，b 的值：" << b << endl;
 
   /* 调用函数来交换值 */
   swap(a, b);
 
   cout << "交换后，a 的值：" << a << endl;
   cout << "交换后，b 的值：" << b << endl;    //200 100
 
   return 0;
}
// 函数定义
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=20)    //设置默认的参数b为20
{
    int result;
    result=a+b;
    return(result);
}
int main()
{
    int c=100;
    int result;
    result=sum(c);    //a参数是传进去的值，b参数采用默认
    cout<<result<<endl;
    return 0 ;
}

lambda匿名函数

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

用的时候再看的链接

posted @ 2019-07-07 22:24 0点0度阅读(1832) 评论(0) 编辑收藏举报

刷新页面返回顶部

0点0度