• 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) 为真。

    位运算符:

    pqp & qp | qp ^ 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 << " 是质数 
    ";
            }
        }
        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匿名函数

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

     用的时候再看的链接

        

  • 相关阅读:
    【工业控制】What is a Waveform
    【工业控制】什么是波形
    【工业控制】学习喷墨打印技术 怎么能不知道波形
    【工业控制】UV打印机喷头波形和墨水关系
    VMware-workstation-full序列码
    【Centos】Centos7.5取消自动锁屏功能
    微信公众平台开发入门教程(图文)
    微信公众平台开发(34)微相册
    微信公众平台开发(33)在线点歌/在线音乐
    微信公众平台开发(32)快递物流
  • 原文地址:https://www.cnblogs.com/0-lingdu/p/10557896.html
Copyright © 2020-2023  润新知