c++基础语法规则

时间  2019-11-09
标签 c++ 基础 语法 规则 栏目 C&C++ 繁體版
原文   原文链接

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

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

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

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

#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;
}

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

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

extern存储类就是调用前一个文件里的全局变量，省的本身去定义了，或者本身没法初始化，因此‘继承’一个过来。this

实例：spa

/*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 说明符仅适用于类的对象，不知因此，留后。.net

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匿名函数

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

 用的时候再看的连接

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程