c++常用的新特性--＞day04

平凡类型

1、默认的构造、析构
2、拷贝构造和移动构造
3、默认的赋值运算符重载和移动赋值运算符重载
且不包含虚函数和虚基类

移动赋值运算符

#include <iostream>
#include <utility> // std::moveclass MyArray {
private:int* data;size_t size;public:// 构造函数MyArray(size_t size) : data(new int[size]), size(size) {std::cout << "Constructed MyArray of size " << size << std::endl;}// 析构函数~MyArray() {delete[] data;}// 拷贝构造函数MyArray(const MyArray& other) : data(new int[other.size]), size(other.size) {std::copy(other.data, other.data + size, data);std::cout << "Copied MyArray of size " << size << std::endl;}// 移动构造函数MyArray(MyArray&& other) noexcept : data(other.data), size(other.size) {other.data = nullptr; // 将 other 置空，防止双重删除other.size = 0;std::cout << "Moved MyArray of size " << size << std::endl;}// 移动赋值运算符MyArray& operator=(MyArray&& other) noexcept {if (this != &other) {       // 1. 检查自赋值delete[] data;          // 2. 释放当前资源data = other.data;      // 3. 转移资源size = other.size;other.data = nullptr;   // 4. 重置传入对象other.size = 0;std::cout << "Move-assigned MyArray of size " << size << std::endl;}return *this;               // 5. 返回当前对象的引用}// 显示数组大小void displaySize() const {std::cout << "Array size: " << size << std::endl;}
};int main() {MyArray arr1(10);               // 创建一个大小为10的数组MyArray arr2(20);               // 创建一个大小为20的数组arr2 = std::move(arr1);         // 使用移动赋值，将 arr1 的资源转移到 arr2arr2.displaySize();             // 显示 arr2 的大小arr1.displaySize();             // 显示 arr1 的大小（应为 0）MyArray arr3 = std::move(arr2); // 使用移动构造函数arr3.displaySize();             // 显示 arr3 的大小arr2.displaySize();             // 显示 arr2 的大小（应为 0）return 0;
}

标准布局类型

1、所有非静态成员有相同 的访问权限（public，private，protected）
2、非静态成员只要同时出现在派生类和基类间，即不属于标准布局。
2.5、对于多重继承，一旦非静态成员出现在多个基类中，即使派生类中没有非静态成员变量，派生类也不属于标准布局。
3、没有虚函数和虚基类。

4、所有非静态数据成员均符合标准布局类型，其基类也符合标准布局，这是一个递归的定义。
5、子类中第一个非静态成员的类型与其基类不同

对POD类型的判断

判断平凡类型

#include <iostream>
#include <type_traits>
using namespace std;class A {};
class B { B() {} };
class C : B {};
class D { virtual void fn() {} };
class E : virtual public A { };int main()
{cout << std::boolalpha;cout << "is_trivial:" << std::endl;cout << "int: " << is_trivial<int>::value << endl;cout << "A: " << is_trivial<A>::value << endl;cout << "B: " << is_trivial<B>::value << endl;cout << "C: " << is_trivial<C>::value << endl;cout << "D: " << is_trivial<D>::value << endl;cout << "E: " << is_trivial<E>::value << endl;return 0;
}

判断标准类型

#include <iostream>
#include <type_traits>
using namespace std;struct A { };
struct B : A { int j; };
struct C
{
public:int a;
private:int c;
};
struct D1 { static int i; };
struct D2 { int i; };
struct E1 { static int i; };
struct E2 { int i; };
struct D : public D1, public E1 { int a; };
struct E : public D1, public E2 { int a; };
struct F : public D2, public E2 { static int a; };
struct G : public A
{int foo;A a;
};
struct H : public A
{A a;int foo;
};int main()
{cout << std::boolalpha;cout << "is_standard_layout:" << std::endl;cout << "A: " << is_standard_layout<A>::value << endl;cout << "B: " << is_standard_layout<B>::value << endl;cout << "C: " << is_standard_layout<C>::value << endl;cout << "D: " << is_standard_layout<D>::value << endl;cout << "D1: " << is_standard_layout<D1>::value << endl;cout << "E: " << is_standard_layout<E>::value << endl;cout << "F: " << is_standard_layout<F>::value << endl;cout << "G: " << is_standard_layout<G>::value << endl;cout << "H: " << is_standard_layout<H>::value << endl;return 0;
}

vs会优化，在linux下
执行结果：

is_standard_layout:
A: true
B: true
C: false
D: true
D1: true
E: false
F: false
G: true
H: false

默认函数控制

==fault

#include <iostream>
using namespace std;class Test
{
public:Test() = default;Test(int i) { obj = i; };~Test() = default;Test(const Test& t) = default;Test(Test&& t) = default;Test& operator=(Test&& t) = default;Test& operator=(const Test& t) = default;int obj=100;
};class Test01
{
public:Test01();
};Test01::Test01() = default;int main()
{Test t1(123);Test t2;t2 = t1;cout << t2.obj << endl;return 0;
}

用了==fault表示使用系统默认的平凡函数

==delete

==delete可以设置默认的平凡函数也可以是自己自定义的函数