c++初学（2）

1、const

const在c语言在：
const:修饰的是一个变量，不能通过被修饰的内容去改变空间的值。
const 在c++中：
const修饰的是一个常量。它具有一些特性
（1）const常量存放在符号表中，正常情况下内存不会为其分配空间
（2）使用时，会去符号表中取值
（3）如果对const常量取地址，编译器会在内存中分配一块无名空间，但它本身不会使用

1、const在c++中的运用：
替换宏常量
2、const与define 的区别：
const:在编译的时候处理，工作是填写符号表，常量有类型，会进行作用域检测，只在符号表中有一个备份
define:在预处理的时候处理，工作是进行完全替换，常量没类型，不会进行作用域检测，在程序中可能有多个备份。
3、const与define 的相同点
都可以定义常量

#include <iostream>

using namespace std;

//c语言中const修饰变量，值可以通过其他方式改变
//c++中const 修饰的是常量，存放在符号表中，是不能改变值的。
int main()
{
    const int a = 10;
    int *pa = (int *)&a;
    *pa = 20;

//    cout << "&a =" << &a << endl;
//    cout << "pa =" << pa << endl;
//    cout << "a =" << a << endl;
//   cout << "*pa =" << *pa << endl;

    printf("摔摔打打\n");
    printf("&a = %p,pa = %p\n",&a,pa);
    printf("a = %d,*pa = %d\n",a,*pa);

    return 0;
}

2、引用1、引用的本质：常指针

int a;
int &ra = a; ra ------> int *const pa;

2、注意点：定义引用的时候必须要赋予初值

3、引用的目的
简化程序，在一定程度上可以替代指针

4、引用使用的大小
在32位机器上是4个字节

5、指针引用

6、常引用

7、函数引用

#include <iostream>

using namespace std;

//1、引用的使用类型 &别名
//引用别名的空间是被引用变量的空间
//注意：定义引用的时候必须要赋予初值
int main1()
{
    int a = 10;
    int &ra = a;        //ra 与 a是同一块空间

    ra = 20;
    cout << "a = " << a << endl;

    return 0;
}

//为什么要用引用：简化程序，在一定程度上上可以替换指针

void myswap(int *pa,int *pb)
{
    int tmp = *pa;
    *pa = *pb;
    *pb = tmp;
}

void myswap(int &pa,int &pb)
{
    int tmp = pa;
    pa = pb;
    pb = tmp;
}


int main2()
{
    int a = 10;
    int b = 20;

    myswap(&a,&b);      //运用指针交换a,b
    cout << "a = " << a << ",b = " << b << endl;

    myswap(a,b);        //运用引用交换a,b
    cout << "a = " << a << ",b = " << b << endl;

    return 0;
}

//3、引用用于结构体
struct student
{
    int id;
    char name[20];
};

void myprintf(student &rs)
{
    printf("id = %d,name = %s",rs.id,rs.name);
}

int main()
{
    student s = {10,"小白"};

    myprintf(s);

    return 0;
}

//4、引用的大小:32位系统上是4个字节
struct text
{
    int &ra;
};

int main4()
{
    printf("sizeof(text) = %d\n",sizeof(text));

    return 0;
}

3、内联函数

1、怎么定义内联函数
在函数定义前加上inline 关键字，在函数声明前加无效

2、使用内联函数的优点：
在函数调用的时候，用函数定义替换，避免函数出栈、入栈、跳转的开销。

3、内联函数与宏函数的区别
内联函数是在编译的时候处理的。
宏函数是在预处理的时候处理的

4、使用内联函数需要注意的地方：
（1） 内联函数是一种请求，可能会失败
（2）在程序运行的时候，内联函数是没有代码空间的，在编译的时候已经替换完了
因此不能对内联函数取地址（也就是内联函数不能作为回调函数）————不可调试（如果调试进入，说明内联函数请求失败了）
（3）内联函数的函数体不要太大，（没有规定，建议不要超过5行）
（4）内联函数不能有任何的循环语句
（5）内联函数不能有太复杂的判断语句

5、内联函数是存放在符号表中的

#include <iostream>

using namespace std;

inline int Add(int a,int b)
{
    return (a+b);
}

int main()
{
    cout << Add(1,2) << endl;

    return 0;
}

4、c++11新特性

//1、自动类推导----->auto
int main1()
{
    auto a = 10;    //a是int类型
    auto b = 'a';   // b是char类型
    auto c = 1.2;   // c是double类型
    cout << a << b << c << endl;

    return 0;
}

//2、空指针类型----->nullptr
int main2()
{
    int *p = nullptr;

    return 0;
}

//3、可以统一初始化----->所有变量都可以用{}统一初始化
int main3()
{
    int a{4};
    cout << a << endl;

    char c{'c'};
    cout << c << endl;

    int buf[5]{1,2,3,4,5};
    for(int i=0;i < 5;i++)
    {
        cout << buf[i] << endl;
    }

    int *p = new int{10};
    cout << *p << endl;

    int *pa = new int[5]{1,2,3,4,5};
    for(int i=0;i < 5;i++)
    {
        cout << pa[i] << endl;
    }
    delete p;
    delete pa;

    return 0;
}

//4、初始列表----->initializer_list<元素类型>
//提供2个函数 begin:指向列表第一个元素end:指向列表最后一个元素的下一个位置
void func(initializer_list<int> nums)
{
      auto pa = nums.begin();
      auto pb = nums.end();

      while(pa != pb)
      {
          cout << *pa << " ";
          pa++;
      }
      cout << endl;

      for(auto pa =nums.begin();pa != nums.end();pa++)
      {
          cout << *pa << " ";
      }
      cout << endl;
      for(auto num : nums)
      {
          cout << num << " ";
      }
      cout << endl;
}

int main4()
{
    func({1,2,3,4,2,1,5});

    return 0;
}

//for 新的遍历方式
//依次将buf 中的元素赋值给a
int main()
{
    int buf[10]{1,2,3,4,5,6,7,8,9,10};
    for(int a : buf)
    {
        cout << a << " ";
    }
    cout << endl;

    return 0;
}