C++笔记-3

C/C++ 中 volatile 关键字详解

  volatile用于随时可能发生变化的变量，避免因为编译器优化程序而出错。编译器在多次访问一个变量时，并不会一直通过寻址访问，而是访问寄存器中已经存好的副本（因为快），这时如果出现一些编译器预料之外的改动就会出错。如内嵌汇编操纵栈”、多线程并发访问共享变量时，一个线程改变了变量的值，其他线程可能看不见改动。因此volatile 的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值，如下：

  链接：https://www.runoob.com/w3cnote/c-volatile-keyword.html

#include <stdio.h>
 
void main()
{
    int i = 10;
    int a = i;
 
    printf("i = %d", a);
 
    // 下面汇编语句的作用就是改变内存中 i 的值
    // 但是又不让编译器知道
    __asm {
        mov dword ptr [ebp-4], 20h
    }
 
    int b = i;
    printf("i = %d", b);
}

//release运行结果：
//i = 10
//i = 10

  加了关键字后每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读到寄存器（或高速缓存）中的数据放在b中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说 volatile 可以保证对特殊地址的稳定访问。加入volatile int i = 10;第二次i=32,符合预期

C/C++ 中 左值、右值、右值引用

  链接https://nettee.github.io/posts/2018/Understanding-lvalues-and-rvalues-in-C-and-C/

class Intvec
{
public:
    explicit Intvec(size_t num = 0)
        : m_size(num), m_data(new int[m_size])
    {
        log("constructor");
    }

    ~Intvec()
    {
        log("destructor");
        if (m_data) {
            delete[] m_data;
            m_data = 0;
        }
    }

    Intvec(const Intvec& other)
        : m_size(other.m_size), m_data(new int[m_size])
    {
        log("copy constructor");
        for (size_t i = 0; i < m_size; ++i)
            m_data[i] = other.m_data[i];
    }

    Intvec& operator=(const Intvec& other)
    {
        log("copy assignment operator");
        Intvec tmp(other);
        std::swap(m_size, tmp.m_size);
        std::swap(m_data, tmp.m_data);
        return *this;
    }
private:
    void log(const char* msg)
    {
        cout << "[" << this << "] " << msg << "\n";
    }

    size_t m_size;
    int* m_data;
};

  main.cpp:

Intvec v2;
cout << "assigning rvalue...\n";
v2 = Intvec(33);
cout << "ended assigning rvalue...\n";

  右值引用：

Intvec& operator=(Intvec&& other)
{
    log("move assignment operator");
    std::swap(m_size, other.m_size);
    std::swap(m_data, other.m_data);
    return *this;
}

1. Intvec& operator=(const Intvec& other)如果不加const,那么右值Intev(33)传不进去，因为引用是左值，但右值和常量左值可以绑定。去掉const会报错。不用右值引用的方法是把传进来的右值赋值给左值，再swap()。
2. 在C++11之后，swap()中可以传右值引用了。
3. 在不能用右值引用的情况下想把右值传进函数Intvec& operator=(const Intvec& other)，只能在传参处加const，利用常量左值可以绑定右值把右值传进来，然后在按照右值做一个左值副本传进swap()。为什么不能直接向swap()内传对象other?因为swap()内不能传const对象，多以必须建一个副本。可见C++11引入右值引用就完全解决了这个问题。

std::move()

  链接：https://blog.csdn.net/p942005405/article/details/84644069

  在C++11中，标准库在中提供了一个有用的函数std::move，std::move并不能移动任何东西，它唯一的功能是将一个左值强制转化为右值引用，继而可以通过右值引用使用该值，以用于移动语义。
  从实现上讲，std::move基本等同于一个类型转换：static_cast(lvalue);

1. C++ 标准库使用比如vector::push_back 等这类函数时,会对参数的对象进行复制,连数据也会复制.这就会造成对象内存的额外创建, 因此在push_back()中定义了通过传入右值来执行移动构造函数来节省内存,通过std::move创建对象的右值，可以避免不必要的拷贝操作。

2. std::move是将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存的搬迁或者内存拷贝所以可以提高利用效率,改善性能.。

3. 对于内置类型（如 int、float、double 等），它们的复制和移动本质上是相同的，因为它们的值都是在栈上分配的，没有动态资源需要管理。因此，即使使用 std::move() 将其转换为右值引用，实际上也只是将其视为右值，但不会导致任何性能上的提升。

4. 性能提升通常是与管理动态资源相关的。例如，在使用自定义类型、STL容器或者智能指针等情况下，它们通常会涉及动态内存的分配和释放，以及资源的所有权转移。在这种情况下，使用 std::move() 可以显著提升性能，因为移动操作只是简单地将资源的所有权从一个对象转移到另一个对象，而不需要进行深层的复制操作。这样可以避免额外的内存分配和释放，从而提高程序的性能。

#include <iostream>
#include <utility>
#include <vector>
#include <string>

int main()
{
    std::string str = "Hello";
    std::vector<std::string> v;

    v.push_back(str);
    std::cout<<"After copy, str is"<<str;//"Hello"

    std::cout<<v[0];
    v.push_back(std::move(str));
    std::cout<<"After move,str is"<<str;//""

}

emplace_back()和push_back()

  链接：https://zhuanlan.zhihu.com/p/213853588
  二者的主要区别在于对于存放右值对象时的不同。C++11之后，二者仅在一种情况下存在区别：

class Person {
    int _age;

public:
    Person(int age) : _age(age) {
        cout << "Construct a person." << _age << endl;
    }

    Person(const Person &p) : _age(p._age) {
        cout << "Copy-Construct" << _age << endl;
    }

    Person(const Person &&p) noexcept: _age(p._age) {
        cout << "Move-Construct" << _age << endl;
    }//移动构造要在函数名后面加 noexpect
};

  二者唯一的区别如下：

int main() {
    using namespace std;
    vector<Person> person;

    person.emplace_back(1); //Construct a person.1

    person.push_back(1);//Construct a person.1, Move-Construct1（移动构造函数）

    //上述情况中emplace_back显然更高效
}

  剩下的情况：

1. 向vector中放入左值（对象）：person.push_back(p);person.emplace_back(p);都是调用构造函数，拷贝构造函数。
2. 向vector中放入右值（临时对象）person.push_back(Person(1));person.emplace_back(Person(1));都是调用构造函数，移动构造函数。
3. 向vector中放入右值（临时对象）person.push_back(std::move(p));person.emplace_back(std::move(p));和上面一样，都是调用构造函数，移动构造函数，因为都是传了一个右值。std::move()将传入的左值强制转换为右值，如string类型。但自己构造的类对象，基本类型则不会。

int main() {
    using namespace std;
    vector<Person> person;
    auto p = Person(1); // >: Construct a person.1   
    person.emplace_back(move(p)); // >: Move-Construct1  如果emplace_back(p)就会调用Copy-Construct1
    person.emplace_back(2);
    /**
     * >: Construct a person.2  // 构建一个新的元素
     * >: Move-Construct1       // 拷贝之前的元素过来，这个时候用的是 Person(const Person &&p)
     */
}

  在上面例子中，注意加入第二个对象后，vector会扩容，原先就有的p是移动构造到更大的vector中的。将上面例子中emplace_back换为push_back结果是一样的，这是因为C++11后，push_back()和emplace_back()都对传入右值做了设计，唯一有区别的地方就是直接传入对象参数时emplace_back就地构造，而不是像push_back要构造再移动构造。剩余情况而是都是要先构造，再复制/移动构造。
  除此之外，如果设计的类中没有设计移动构造，那么原本要移动构造可以向下兼容成拷贝构造。

这里提供一个调试的demo:

class BaseClassTwoPara {
    public:
        BaseClassTwoPara(int a)
        {
        m_a = a;
        m_b = 999;
        cout << "construct " << m_a << " " << m_b << endl;
        }
        BaseClassTwoPara(int a, int b)
        {
            m_a = a;
            m_b = b;
            cout << "construct " << m_a << " " << m_b << endl;
        }
        BaseClassTwoPara(const BaseClassTwoPara &rhs)
        {
            m_a = rhs.m_a;
            m_b = rhs.m_b;
            cout << "copy construct " << m_a << " " << m_b << endl;
        }

        BaseClassTwoPara(const BaseClassTwoPara &&rhs)
        {
            m_a = rhs.m_a;
            m_b = rhs.m_b;
            cout << "move copy construct " << m_a << " " << m_b << endl;
        }

        ~BaseClassTwoPara()
        {
            cout << "delete " << m_a << " " << m_b << endl;
        }
    int m_a, m_b;
};



void test_TwoPara_push_back_cp()
{
    vector<BaseClassTwoPara> vl;
    BaseClassTwoPara p(1);
    vl.push_back(std::move(p));
    cout << "test_TwoPara_push_back_cp" << endl;
}

Const修饰变量、成员函数、返回值

  链接：https://zhuanlan.zhihu.com/p/110159656

#include<iostream>

using namespace std;

class A
{
public:
    int data;
public:
    A(int num):data(num){}
    ~A(){};
    
    int& get_data()
    {
        data=2;
        return data;
    }
};

int main()
{
    const A a(1);
    a.get_data();//错误
    std::cout<<a.data;

    return 0;
}

1. const a调用不了没被const修饰的成员函数,要在int& get_data()后加const。
2. non-const a可以调用int& get_data() const

下面讲解实际原理
  链接：https://blog.csdn.net/weixin_45031801/article/details/133906995
  链接：https://blog.csdn.net/weixin_45031801/article/details/134161230

#include <stdio.h>
#include <iostream>
using namespace std;


class Date
{
public:
	//构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Printf() //Printf(Date* const this)
	{
		cout << _year<< _month << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
 
void Func(const Date& d)
{
	d.Printf();//d.Printf(&d),所以在Func()中调用Printf()传入&d，其指针类型是const Data*
}
 
int main()
{
	Date d1(2023, 11, 1);
	d1.Printf();//d1.Printf(&d1,其指针类型是Data*,Data*转化为Date* const this没有问题，限制范围缩小
	Date d2(2023, 11, 2);
	Func(d2);//发生错误，因为编译器检测到const Data*被转换为Data* const，该转换是十分危险的！这也就是const对象（d2在Func函数中被转化成const对象）无法调用non-const成员函数的真正原因！
	return 0;
}

1. 成员函数实际上隐藏了this指针，void Printf()实际上是void Printf(Date const this);Date(int year, int month, int day)实际上是Date(Date const this，int year, int month, int day)，也就是指针指向是不可改变的（永远指向自己）。在用户调用时d1.Print()；实际上是d1.Print(&d1);简而言之，把自己的指针传了进去。这些都是编译器要做的部分。
2. 发生错误原因：const对象无法调用non-const成员函数。究其本质为const Data 转化为 Data const是存在歧义的。解决方法是把void Printf( Date const this) 变为 void Printf(const Date const this)，但由于this指针是隐含的，我们默许不让this出现在成员函数之中，因此经典的const成员函数出现了：
   void Print() const 等价于void Print(const Date* const this)。权限缩小，可以。权限扩大，不行。
3. const成员函数不可以调用非const成员函数，void Fun( const Date& d){d.printf()};非const成员函数可以调用其他const成员函数。

static修饰变量与函数

链接：https://blog.csdn.net/weixin_45031801/article/details/134215425?spm=1001.2014.3001.5502

static修饰局部变量

  局部静态变量也是放在静态区（和全局变量放在一起）。生命周期为整个程序周期，并且不用赋值，默认为0。

static修饰全局变量

  全局变量的作用域十分的广，只要在一个源文件中定义后，这个程序中的所有源文件、对象以及函数都可以调用，生命周期更是贯穿整个程序。文件中的全局变量想要被另一个文件使用时就需要进行外部声明（以下用extern关键字进行声明）。——-也即是说全局变量既可以在源文件中使用，也可以在其他文件中使用（只需要使用extern外部链接以下即可）
  static修饰全局变量和函数时，会改变全局变量和函数的链接属性———-变为只能在内部链接，从而使得全局变量的作用域变小。如果全局变量被static修饰，那这个外部链接属性就会被修改成内部链接属性，此时这个全局变量就只能在自己的源文件中使用；

1. static的另一个作用是默认初始化为0。其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵，我们可以一个一个地把所有元素都置0，然后把不是0的几个元素赋值。如果定义成静态的，就省去了一开始置0的操作。
2. 存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。之后再次运行到含有 static 关键字的初始化语句时不会再执行该语句。共有两种变量存储在静态存储区：全局变量和 static 变量，只不过和全局变量比起来，static 可以控制变量的可见范围。

C++中的static

class A
{
private:
	static int _n;
	int _k;
	char _a;
};
int A::_n=0;//定义

int main()
{
	cout << sizeof(A) << endl; //8
	return 0;
}

1. 这里A的大小是8，这是因为静态成员变量不会每个对象都创建一个，而是所有对象共享类中声明的这一个，其作用域限制在类之内。
2. 静态成员要在类外定义，定义时不添加static关键字
3. 静态成员函数没有隐藏的this指针，没有向函数中传this指针也就不能访问任何非静态成员

class A
{
public:
	static void Func()
	{
		cout << ret << endl;  // err错误，访问了非静态成员，因为无this指针
		cout << _k << endl; //正确
	}
private:
	//声明
	int ret = 0;
	static int _k;
};
//定义
int A::_k = 0;

当静态成员变量为public时，可有如下三种进行访问：通过对象.静态成员来访问；通过类名::静态成员来行访问；通过匿名对象突破类域进行访问

class A
{
public:
// 声明
	static int _k;
};
// 定义
int A::_k = 0;
int main()
{
	A a;
	cout << a._k << endl;  //通过对象.静态成员来访问
	cout << A::_k << endl; //通过类名::静态成员来行访问
	cout << A()._k << endl;//通过匿名对象突破类域进行访问
	return 0;
}

当静态成员变量变成private时，可采用如下方式：通过对象.静态成员函数来访问；通过类名::静态成员函数来行访问；通过匿名对象调用成员函数进行访问

class A
{
public:
	static int GetK()
	{
		return _k;
	}
private:
	static int _k;
};
int A::_k = 0;
int main()
{
	A a;
	cout << a.GetK() << endl; //通过对象.静态成员函数来访问
	cout << A::GetK() << endl;//通过类名::静态成员函数来行访问
	cout << A().GetK << endl; //通过匿名对象调用成员函数进行访问
	return 0;
}

注意：

1. 静态成员函数不可以调用非静态成员函数吗？因为静态成员函数是没有this指针的，无法调用非静态成员函数。
2. 非静态成员函数可以调用类的静态成员函数吗。因为静态成员为所有类对象所共享，不受访问限制

linux系统下的一些权限问题

  用户权限、所有组、更改权限：https://blog.csdn.net/weixin_45031801/article/details/133876760?spm=1001.2014.3001.5502
  sudo存在的意义：https://zhuanlan.zhihu.com/p/137332644

利用引用初始化类，并且默认拷贝构造函数， copy assignment operator复制问题

#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;


class Person {

public:
    Person (std::string& name) :nameValue(name)
    {
        //如果传引用，必须也只能用初始化列
        //不用初始化列而是
        //nameValue = name;错误，会提示nameValue初始化失败，这也印证了在构造函数之前编译器默认初始化，在构造函数中是赋值操作，在构造函数中不会初始化。
    }

private:
  std::string& nameValue;

};

int main() {
  std::string newdag("nnnn");
  std::string ncatg("bbbbb");
  Person p1(newdag);
  Person p2(ncatg);
  p1 = p2;//错误，这里会提示note: 'Person& Person::operator=(const Person&)' is implicitly deleted because the default definition would be ill-formed错因见effective P37。要自己定义 = 函数

}

  同样要注意，如果是通过Person p1(p2);调用拷贝构造函数，string&给string&赋值的操作其实会调用string()的构造函数给p1中的string&初始化。

派生类的拷贝构造

#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;


class Person {

public:

    Person (int name): _name(name)
    {
      cout<<"joaf"<<endl;
      cout<<static_cast<void*>(this)<<endl;
    }

    Person(const Person& p):_name(p._name)
    {
      cout<<"aed"<<endl;
    };

    int get_name() const
    {
      return _name;
    }
private:
    int _name;

};



class Person1: public Person{

public:

    Person1 (int name): Person(name)
    {
        cout<<"person1"<<static_cast<void*>(this)<<endl;

    }

    Person1(const Person1& p):Person(p.get_name())
    {
      cout<<"hhh"<<endl;
    };

private:

};


int main() {

  Person1 p1(2);
  Person1 p2(p1);
  cout<<"p2的name"<<p2.get_name();


}

1. 派生类的任何构造函数都要带基类的拷贝构造函数，否则会调用拷贝构造函数。
2. Person1(const Person1& p):Person(p.get_name())中get_name传的this指针是const Person* const类型，因此要求get_name()必须是const修饰的成员函数。
3. 实例化一个派生类时肯定会附带生成一个基类。
4. 拷贝构造函数中传的必须是const类型引用，pass-by-value会无限调用自身，不加const会导致用户传入const实参时会出现权限（范围）冲突。
5. 纯虚函数定义部分用=0代替，=0告诉编译器函数没有主体，改函数是纯虚函数
6. =delete，C++11中，当我们定义一个类的成员函数时，如果后面使用”=delete”去修饰，那么就表示这个函数被定义为deleted，也就意味着这个成员函数不能再被调用，否则就会出错。

对于构建的类，编译器默认生成的函数

链接：https://zhuanlan.zhihu.com/p/111652531

在C++中定义一个空类 class Dog {};

class Dog {
// C++03
  Dog(); // 默认构造函数
  Dog(const Dog&); // 拷贝构造函数
  ~Dog() // 析构函数
  // 拷贝赋值运算符
  Dog& operator=(const Dog&);

// C++11 新增
  Dog(Dog&&); // 移动构造函数
  // 移动赋值运算符
  Dog& operator=(Dog&&);

};

生成规则：

1. 默认构造函数：只在用户没有定义其它类型构造函数时才会生成。
2. 拷贝构造函数：只有用户没有定义 移动构造函数(5) 和 移动赋值运算符(6) 时，才会生成。
3. 拷贝赋值运算符：只有用户没有定义 移动构造函数(5) 和 移动赋值运算符(6) 时，才会生成。
4. 析构函数：无限制。
5. 移动构造函数：只有用户没有定义 拷贝构造函数(2), 拷贝赋值运算符(3), 析构函数(4) 和 移动赋值运算符(6) 时，才会生成。
6. 移动赋值运算符：只有用户没有定义 拷贝构造函数(2), 拷贝赋值运算符(3), 析构函数(4) 和 移动构造函数(5) 时，才会生成。

  注意一个类class X
  X x1;std::move(x1);这样输出x1中的值不会有任何影响。
  但X x1; X x2 = std::move(x1);这样输出x1中的值就被转移走了。

void do_stuff(X&& x_)
{
    X a(x_);//这里会调用拷贝构造函数
    X b(std::move(x_));//移动构造函数
    //参数进入函数内部被当作左值处理
}

C++ Lambda表达式

链接：https://zhuanlan.zhihu.com/p/384314474
链接：https://xiaodongfan.com/

C++ static、const 类型成员变量声明以及初始化，constexpr，常量表达式与字面值

声明时初始化、初始化列表初始化、构造函数中初始化

  成员变量初始化的顺序为：先进行声明时初始化，然后进行初始化列表初始化，最后进行构造函数初始化。

#include <iostream>
using namespace std;
class A 
{
public:
   
    A() {}
    A(int a_):a(a_){}
    A(int a_, bool b) :a(4) { a = a_; }

public：
    int a = 1;
private:
    const int a;
    static int b;

};

int A::b = 5;
 
int main()
{
    A a1, a2(3), a3(5, true);
    cout << "a1.a=" << a1.a << endl;
    cout << "a2.a=" << a2.a << endl;
    cout << "a3.a=" << a3.a << endl;
    system("pause");
    return 0;
}

1. static成员变量不能在构造函数初始化列表中初始化，因为它不属于某个对象。定义必须在类的外部实现。其在构造函数中是赋值行为。
2. const 数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其 const 数据成员的值可以不同。所以不能在类的声明中初始化 const 数据成员，因为类的对象没被创建时，编译器不知道 const 数据成员的值是什么。
   const 数据成员的初始化只能在类的构造函数的初始化列表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。

常量表达式，const,constexpr,编译时常量，运行时常量

链接：https://blog.csdn.net/aruewds/article/details/118938121
链接：https://xiaodongfan.com/C-%E5%B8%B8%E9%87%8F%E8%A1%A8%E8%BE%BE%E5%BC%8F-constexpr.html
链接：https://www.runoob.com/w3cnote/cpp-static-const.html
链接：https://blog.csdn.net/gyxqwe/article/details/78587078
链接：https://blog.csdn.net/yao_hou/article/details/109301290

字面值：是一个不能改变的值，如数字、字符、字符串等。单引号内的是字符字面值，双引号内的是字符串字面值。
字面值类型（literal type）：算数类型、引用和指针等。

常量表达式（const experssion）：是指(1)值不会改变 并且 (2)在编译过程就能得到计算结果的表达式。字面量属于常量表达式，用常量表达式初始化的const对象也是常量表达式。
一个对象（或表达式）是不是常量表达式由它的数据类型和初始值共同决定。

const int a =1;		//常量表达式
cosnt int b=a+1;	//常量表达式
int c=2;		//初始值是字面值常量，当c数据类型是普通int。
const int d=fun();	//fun()值要在运行时得到，d不是字面值常量。

C++11新标准规定，允许将变量声明为constexpr类型以便由编译器来验证变量的是否是一个常量表达式。
声明为constexpr的变量一定是一个常量，而且必须用常量表达式初始化。

const与constexpr区别

1. const 和 constexpr 变量之间的主要区别在于：const 变量的初始化可以延迟到运行时，而 constexpr 变量必须在编译时进行初始化。所有 constexpr 变量均为常量，因此必须使用常量表达式初始化。

2. 在使用const时，如果关键字const出现在星号左边，表示被指物是常量；如果出现在星号右边，表示指针本身是常量；如果出现在星号两边，表示被指物和指针两者都是常量。
   与const不同，在constexpr声明中如果定义了一个指针，限定符constexpr仅对指针有效，与指针所指对象无关。

3. constexpr是一种很强的约束，更好的保证程序的正确定语义不被破坏；编译器可以对constexper代码进行非常大的优化，例如：将用到的constexpr表达式直接替换成结果, 相比宏来说没有额外的开销。

#include <iostream>
using namespace std;
 
int g_tempA = 4;
const int g_conTempA = 4;
constexpr int g_conexprTempA = 4;
 
int main(void)
{
	int tempA = 4;
	const int conTempA = 4;
	constexpr int conexprTempA = 4;
 
	/*1.正常运行,编译通过*/
	const int *conptrA = &tempA;
	const int *conptrB = &conTempA;
	const int *conptrC = &conexprTempA;
 
	/*2.局部变量的地址要运行时才能确认，故不能在编译期决定，编译不过*/
	constexpr int *conexprPtrA = &tempA;
	constexpr int *conexprPtrB = &conTempA;
	constexpr int *conexprPtrC = &conexprTempA;
 
	/*3.第一个通过，后面两个不过,因为constexpr int *所限定的是指针是常量，故不能将常量的地址赋给顶层const*/
	constexpr int *conexprPtrD = &g_tempA;
	constexpr int *conexprPtrE = &g_conTempA;
	constexpr int *conexprPtrF = &g_conexprTempA;
 
	/*4.局部变量的地址要运行时才能确认，故不能在编译期决定，编译不过*/
	constexpr const int *conexprConPtrA = &tempA;
	constexpr const int *conexprConPtrB = &conTempA;
	constexpr const int *conexprConPtrC = &conexprTempA;
	/*5.正常运行，编译通过*/
	constexpr const int *conexprConPtrD = &g_tempA;
	constexpr const int *conexprConPtrE = &g_conTempA;
	constexpr const int *conexprConPtrF = &g_conexprTempA;
 
	return 0;
}

用于引用

#include <iostream>
using namespace std;
 
int g_tempA = 4;
const int g_conTempA = 4;
constexpr int g_conexprTempA = 4;
 
int main(void)
{
	int tempA = 4;
	const int conTempA = 4;
	constexpr int conexprTempA = 4;
	/*1.正常运行，编译通过*/
	const int &conptrA = tempA;
	const int &conptrB = conTempA;
	const int &conptrC = conexprTempA;
 
	/*2.有两个问题：一是引用到局部变量，不能再编译器确定；二是conexprPtrB和conexprPtrC应该为constexpr const类型，编译不过*/
	constexpr int &conexprPtrA = tempA;
	constexpr int &conexprPtrB = conTempA;
	constexpr int &conexprPtrC = conexprTempA;
 
	/*3.第一个编译通过，后两个不通过，原因是因为conexprPtrE和conexprPtrF应该为constexpr const类型*/
	constexpr int &conexprPtrD = g_tempA;
	constexpr int &conexprPtrE = g_conTempA;
	constexpr int &conexprPtrF = g_conexprTempA;
 
	/*4.正常运行，编译通过*/
	constexpr const int &conexprConPtrD = g_tempA;
	constexpr const int &conexprConPtrE = g_conTempA;
	constexpr const int &conexprConPtrF = g_conexprTempA;
 
	return 0;
}

简单的说constexpr所引用的对象必须在编译期就决定地址。还有一个奇葩的地方就是可以通过上例conexprPtrD来修改g_tempA的值，也就是说constexpr修饰的引用不是常量，如果要确保其实常量引用需要constexpr const来修饰。内因类似于constexpr修饰指针即要求指针自身是常量，并不要求所指内容是常量，并且g_tempA自身的地址在编译期就可以确定，因此可以通过conexprPtrD来修改g_tempA的值。

C++ 智能指针auto_ptr unique_ptr share_ptr weak_ptr

链接：https://blog.csdn.net/cpp_learner/article/details/118912592

auto_ptr unique_ptr

  auto_ptr是用于C++11之前的智能指针。由于 auto_ptr 基于排他所有权模式：两个指针不能指向同一个资源，复制或赋值都会改变资源的所有权。auto_ptr 主要有三大问题：

1. 复制和赋值会改变资源的所有权，不符合人的直觉（下面的利用右值移动拷贝/赋值显然更符合人的直觉）。
2. 在 STL 容器中使用auto_ptr存在重大风险，因为容器内的元素必需支持可复制（copy constructable）和可赋值（assignable）。
3. 不支持对象数组的操作。

  所以，C++11用更严谨的unique_ptr 取代了auto_ptr！unique_ptr 和 auto_ptr用法几乎一样，除了一些特殊。

1. 基于排他所有权模式：两个指针不能指向同一个资源。
2. 无法进行左值unique_ptr复制构造，也无法进行左值复制赋值操作，但允许临时右值赋值构造和赋值。
3. 保存指向某个对象的指针，当它本身离开作用域时会自动释放它指向的对象。
4. 在容器中保存指针是安全的(但也要用std::move()传右值)。

智能指针三大接口：

1. get() 获取智能指针托管的指针地址

// 定义智能指针
auto_ptr<Test> test(new Test);

Test *tmp = test.get();		// 获取指针返回
cout << "tmp->debug：" << tmp->getDebug() << endl;

//源码：
_NODISCARD _Ty * get() const noexcept
{	// return wrapped pointer
	return (_Myptr);
}

1. release() 取消智能指针对动态内存的托管

// 定义智能指针
auto_ptr<Test> test(new Test);

Test *tmp2 = test.release();	// 取消智能指针对动态内存的托管
delete tmp2;	// 之前分配的内存需要自己手动释放

//源码：
_Ty * release() noexcept
{	// return wrapped pointer and give up ownership
	_Ty * _Tmp = _Myptr;
	_Myptr = nullptr;
	return (_Tmp);
}

  也就是智能指针不再对该指针进行管理，改由管理员进行管理！对象依旧存在。

1. reset() 重置智能指针托管的内存地址，如果地址不一致，原来的会被析构掉

// 定义智能指针
auto_ptr<Test> test(new Test);

test.reset();			// 释放掉智能指针托管的指针内存，并将其置NULL

test.reset(new Test());	// 释放掉智能指针托管的指针内存，并将参数指针取代之

源码：
void reset(_Ty * _Ptr = nullptr)
{	// destroy designated object and store new pointer
	if (_Ptr != _Myptr)
		delete _Myptr;
	_Myptr = _Ptr;
}

  reset函数会将参数的指针(不指定则为NULL)，与托管的指针比较，如果地址不一致，那么就会析构掉原来托管的指针，然后使用参数的指针替代之，然后智能指针就会托管参数的那个指针了。没有参数，则将其释放掉。

auto_ptr 与 unique_ptr智能指针的内存管理陷阱

auto_ptr<string> p1;
string *str = new string("智能指针的内存管理陷阱");
p1.reset(str);	// p1托管str指针

auto_ptr<string> p2;
p2.reset(str);	// p2接管str指针时，会先取消p1的托管，然后再对str的托管


// 此时p1已经没有托管内容指针了，为NULL，在使用它就会内存报错！
cout << "str：" << *p1 << endl;

  为了解决这两种指针的排他性，由此引出share_ptr。

share_ptr

为什么make_shared效率更高？

链接：https://zhuanlan.zhihu.com/p/337656226
  shared_ptr中维护了两个指针，两个内存块，一个是目标对象的指针，对象内存块(我们称被指对象为data_field，定义了share_ptr后根据构造函数创建)，另一个是包含了use_count,weak_count，allocator、deletor的内存块(我们称被指的内容为control_block，这一部分是定义了share_ptr后才创建的)，以及指向这一块的指针。通常data field和control_block是分离的，比如当我们通过如下代码创建一个shared_ptr时：

std::shared_ptr<int> a(new int)

  首先，我们为int类型new出了一块内存，然后在构造__shared_count的时候，又会为control block new出一块内内存，这是两次内存分配，内存分配对系统来说消耗极大，并且产生了内存碎片。

  如果使用std::shared_ptr，那么会把这两块挨着放在一起，这是一次内存分配。

shared_ptr的问题：循环引用

问题参考链接：https://blog.csdn.net/cpp_learner/article/details/118912592

为了解决这个问题，引入了weak_ptr:
  weak_ptr 是为了配合 shared_ptr 而引入的一种智能指针，它指向一个由 shared_ptr 管理的对象而不影响所指对象的生命周期，也就是将一个 weak_ptr 绑定到一个 shared_ptr 不会改变 shared_ptr 的引用计数。不论是否有 weak_ptr 指向，一旦最后一个指向对象的 shared_ptr 被销毁，对象就会被释放。

C时代的遗孤，char* p=”123”和char p[]=”123”的区别

char[] 是数组类型， char 是指针类型。两者根本上是不同的东西。
不同点：
const char初始化”123”，由于”123”是字符串常量，存储在可执行文件的只读数据段，所以是指针p指向了字符串常量。
初始化后者时，字符串p是将字面量的值复制到栈里，命名为p。

int main()
{
    char* p="adssad";
    std::cout << "Address of string literal: " << static_cast<void*>(p) << std::endl;
    cout<<&p<<endl;
    //Address of string literal: 0x7ff7c4875073 //此为字符串开始的地址
    //0x3ade3ffd08   //此为指针p存放的地址

    char p1[]="adssad";
    std::cout << "Address of string literal: " << static_cast<void*>(p1) << std::endl;
    cout<<&p1<<endl;
    //Address of string literal: 0x3ade3ffd01 //此为字符串开始的地址
    //0x3ade3ffd01  //此为字符串开始的地址

}

1. char[] 能隐式转化为char，char可以隐式转换为string,
2. char p=”123”实则会报warning，实际应该是const char p =”123”，因此p[0]=’b’是不对的。
3. string p = “123”,p[0]=’b’是对的,可以改变。

内联函数

链接：https://blog.csdn.net/qq_35902025/article/details/127912415

野指针的产生

指向非法的内存地址指针叫作野指针（Wild Pointer），也叫悬挂指针（Dangling Pointer），意为无法正常使用的指针。
链接：https://blog.csdn.net/Hsuesh/article/details/111212006

使用未初始化的指针

出现野指针最典型的情形就是在定义指针变量之后没有对它进行初始化，如下面的程序:

#include <iostream>

usingnamespacestd;

intmain()

{

  int* p;

  cout<<*p<<endl; //编译通过，运行时出错

}

指针所指的对象已经消亡

指针指向某个对象之后，当这个对象的生命周期已经结束，对象已经消亡后，仍使用指针访问该对象，将出现运行时错误。考察如下程序。

#include <iostream>
usingnamespacestd;

int* retAddr()
{
    intnum=10;
    return&num;
}

intmain()
{
    int* p = nullptr;
    p=retAddr();
    cout<<&p<<endl;
    cout<<*p<<endl;
}

指针释放后之后未置空

指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。对指针进行free和delete，只是把指针所指的内存空间给释放掉，但并没有把指针本身置空，此时指针指向的就是“垃圾”内存。释放后的指针应立即将指针置为NULL，防止产生野指针。考察如下程序。

#include <iostream>
#include "test.h"
typedef void(*Fun)(void);
typedef void (Base::*FunPtr)();


int Base::baseI = 0;

void jj(){
    cout<<"j";
}

int main(int, char**){
    std::cout << "Hello, from makeclass!\n";
    Base b(1000);



    void * vptrAdree = (void *)(&b);  
    //通过打印成员变量，可以看到指向虚表指针(8字节)后面就是成员变量，并且有类似struct的内存对齐。static量不和本类存在一起
    cout << "虚函数指针(vprt)的地址是:\t"<<vptrAdree <<"\t"<<sizeof(vptrAdree)<<"\t"<<&b.baseI<<"\t"<<&b.num<<"\t"<< endl;
    // 打印静态成员函数指针，两种方法原理一致
    void (*funcPtr)() = Base::setI;//等号右侧加不加&都一样
    std::cout << "Function pointer (Base::setI) address: " << (void*)funcPtr <<"\t"<<"\t"<<(void*)Base::setI<< std::endl;
    //打印普通成员函数,this指针的原因，不能按如下方法
    // void (*ffuncPtr)() = Base::ffunc;
    // std::cout << "Function pointer (Base::setI) address: " << (void*)funcPtr << std::endl;
    void (Base::*ffuncPtr)() = Base::ffunc;
    printf("%p\n", Base::ffunc);

    //打印普通函数指针
    cout<<"普通函数地址"<<jj<<(void*)jj<<"普通成员函数"<<endl;

    //方法一
    // 获取 vptr 地址 (vptr 是对象的第一个成员)
    void** vptr = *(void***)(&b); 
    std::cout << "vptr address: " << vptr << std::endl;
    void* vtable = *vptr;
    void* vtable1 = *(vptr+1);
    std::cout << "Virtual function table (vtable) address: " << vtable<<"\t"<<vtable1<<"\t"<<vptr<<"\t"<<vptr+1<< std::endl;
    Fun func = (Fun)vptr[0];//Fun func = (Fun)vtable
    func();
    cout<<"函数指针转void*以打印"<<(void*)func<<endl;

    //方法二
    int a=1;
    cout<<(void*)*(void**)(&b)<<"\t"<<(int64_t*)*(int64_t*)(&b)<<"\t"<<(int*)*(int*)(&b)<<"\t"<<(int*)a<<endl;
    Fun func1 = (Fun)*(int64_t*)*(int64_t*)(&b);
    func1();


    //方法三
    Fun* vfunc = *(Fun**)(&b);
    vfunc[0]();


}

1. warning: cast to pointer from integer of different size [-Wint-to-pointer-cast] cout<<(void)(void*)(&b)<<”\t”<<(int64_t)(int64_t)(&b)<<”\t”<<(int)(int)(&b)<<”\t”<<(int)a;这行代码中，指针都是八字节的，各种可以任意转换，问题出现在(int)(&b),(int)(&b)的意图是取出(int*)(&b)位置存的指针，结果对该位置解引用，解出来的应当八字节的指针而现如今是4字节的int,这是出现在64位机上的错误，八字节的指针被截断成了四字节。而由于32位机指针是4字节32位的，上面的代码是没有问题。这也是为什么把int换成int64_t在64位机上是完全没有问题的。
2. 虚表中，虚析构函数附带着一个未知的函数，相当于虚析构函数占两条，其他虚函数占一个。
3. 由于对void 解引用没有作用，技巧：直接把void 强转为(void )，void 可以解引用，强转为void n*也可以，都是指针罢了，打印出来都一样。
4. 类的实例地址就是指向虚表的指针，一路解引用下去就是指向第一个虚函数的指针。取出该指针后面直接加()就可以调用
5. 对于静态函数和普通函数，函数指针可以直接转化为(void)然后cout打印出函数指针,静态函数的函数签名在本例中就是void( )(void);但对于普通成员函数，例如Base::ffuc() 是一个成员函数指针，类型是 void (Base:: )() ，它与普通函数指针 void ( )() 是不兼容的。因此，不能直接将成员函数指针转换为 void，因为两者的内部表示不同。编译器不知道如何将一个带有 this 指针的成员函数指针转换为简单的 void。(直接打印函数指针而不强转，cout出来都是1)