new int arr[10];
delete [] arr;

//new和delete使用时需要加上数据类型

new int(10) //从堆区获取1个整型的空间，并赋值为10
int *p = new int[10] //从堆区获取10个整型的数组空间

delete [10] p //从堆区释放10个整型的数组空间

namespace A
{
    int a = 100;
}

namespace B
{
    int a = 200;
}

int main()
{
    cout << A::a << endl;
}

namespace A
{
    int a = 100;
}

namespace B
{
    int a = 200;
}

int main()
{
using namespace A
    cout << a << endl;
}

using func_t = void (int);
//或者这样
using func_t = void (*)(int);

template<class T>
using Vec = vector<T, Alloc<T>>; // 类型标识为 vector<T, Alloc<T>>

#include <iostream>
using func_t = void (int);

void hello(func_t func3){
    func3(6);
}

void func(int a){
    std::cout << a << std::endl;
}

int main() {
    hello(func);
    return 0;
}

using func_t = void (int);

void hello(func_t * func3){
    func3(6);
}
//或者下面这样的
using func_t = void (*)(int);

void hello(func_t func3){
    func3(6);
}
//但就不能写成下面的的形式，这会报编译错误 error: cannot convert 'void (*)(int)' to 'void (**)(int)
using func_t = void (*)(int);

void hello(func_t * func3){
    func3(6);
}

//下面3个没问题
typedef  void(*func_t)(int);

void hello(func_t func3){
    func3(6);
}

typedef  void(func_t)(int);

void hello(func_t func3){
    func3(6);
}

typedef  void(func_t)(int);

void hello(func_t * func3){
    func3(6);
}
//这就有问题了
typedef  void(*func_t)(int);

void hello(func_t * func3){
    func3(6);
}

int c = 20;
int a = 10;
int &b = a;
int &b;    //错误，引用必须初始化
int &b = c;//错误，引用不能被更改
b = c;    //正确，将c的值赋值给b所指向的内存

void swap(int &a, int &b)    //相当于形参引用了实参:int &a = a;
{
    int temp = a;
    int a = b;
    int b = temp;
}

int main()
{
    int a = 10;
    int b = 20;
    swap(a, b);
}

int& left_call()
{
    static int a = 10;
    return a;
}

int main()
{
    left_call() = 1000;    //相当于给a所引用的那块内存地址赋值
    return 0;
}

int a = 10;
int &ref = a;    //int* const ref = &a;
int &b = 10;    //错误，10只是一个临时的寄存器变量，不是一个位于内存的持久化的左值
const int& b = 10;    //正确，这样可以避免修改常量区

int func(int a, int b = 10, int c = 20)    //如果b已经有了默认参数，那么b之后的形参也必须要有对应的初值(在C++11后不做要求)
{

}

int func(int a, int b = 10)
{
    cout << "func(int a, int b = 10)" << endl;
}

int func(int a)
{
    cout << "func(int a,)" << endl;
}

int main()
{
    int a = 10;
    fun(a);    //产生二义性，编译错误
    return 0;
}

class person
{
public:
    string get_name()
    {
        return m_name;
    }

    void set_name(string name)
    {
        m_name = name;
    }

    int get_age()
    {
        return m_age;
    }

    void set_paaword(int pswd)
    {
        m_passwaord = pswd;
    }
private:
    string m_name;    //可读可写
    int m_age = 18;    //只读
    int m_password = 123456;     //只写
}；

class person
{
    public:
    person()
    {
        cout << "person的构造" << std::endl;
    }
    ~person()
    {
        cout << "person的析构" << std::endl;
    }
};

int main()
{
    person p;
    return 0;
}

class person
{
    public:
    person(const person &p)
    {
        age = p.age;
    }
};

int main()
{
    person p1;    //默认构造函数
    person p2(10);    //有参构造函数，person(10)为匿名对象
    person p3(p2);    //拷贝构造函数
    person p4 = p3(p2);    //重载()函数，假设已经实现了重载函数
}

class person
{
    public:
    person(const person &p)
    {
        age = p.age;
        height = new int(*p.height);    //实现了深拷贝
    }
    ~person()
    {
        if(height)
            delete height;    //析构函数也要进行处理
    }
};

class person
{
    static int a;
};

int person::a = 10;

class person
{
    public:
    person(int age)
    {
        this->age = age; 
    }
    person& person_ageadd(person& p) //参数类型如果是person&的话就会触发默认拷贝构造函数，此时返回的不是p2本身而是p2'，因此最终输出的p2就是20
    {
        this->age += p.age;
        return *this;
    }

    int age;
};

int main()
{
    person p1(10);
    person p2(10);
    p2.person_ageadd(p1).person_ageadd(p1);    //链式编程
    std::cout << p2.age << std::endl;
}

// 隐式转换：成员函数的 this 指针类型
void func() const;      // 实际：void func(const MyClass* this);
void func();            // 实际：void func(MyClass* this);

class house
{
friend void goodgay(house &h1);    //友元

public:
    int score = 10;
private:
    int password = 123456;
};

void goodgay(house &h1)
{
    std::cout << h1->password << std::endl;
}

class myadd
{
    public:
    operator()(int a, int b)
    {
        return a + b;
    }
};

int main()
{
    int ret;

    // 创建 myadd 的临时匿名对象并调用其 operator()
    // 等价于：
    // myadd temp;
    // ret = temp(1, 2);
    // 临时对象在表达式结束后自动销毁
    ret = myadd()(1, 2);
    std::cout << ret << std::endl;
    return 0;
}

class base
{
public:
    int a;
protected:
    int b;
private:
    int c;
};

class son: protected base
{
public:
    son()    //构造函数无返回类型
    {
        a = 100;    //必须在构造函数内赋值，或者在类内的重载函数内赋值，在函数外赋值是不被允许的
        b = 200;
        c = 300;    //报错
    }
}; 

void func()
{
    son s;
    s.b = 300;    //报错
}

class Base {
public:
    int x = 10;
};

class Derived : public Base {
public:
    int x = 20;  // 隐藏 Base::x
};

//内存布局：
Derived 对象：
+----------------+
| Base::x = 10   |  <-- 父类成员仍然存在！
+----------------+
| Derived::x = 20|  <-- 子类新增成员
+----------------+

#include <iostream>
using namespace std;

class Base {
public:
    void print() { cout << "Base::print()" << endl; }  // 父类成员函数
};

class Derived : public Base {
public:
    void print() { cout << "Derived::print()" << endl; } // 子类同名成员函数
};

int main() {
    Derived obj;
    obj.print();              // 调用子类函数：输出 "Derived::print()"
    obj.Base::print();        // 显式调用父类函数：输出 "Base::print()"
    return 0;
}

class animal
{
public:
    int age;
};

class sheep:virtual public animal
{
public:
    int age = 15;
};

class tuo:virtual public animal
{
public:
    int age = 20;
};

class sheeptuo:public sheep, public tuo
{
public:
    int age = 38;    //age可以重定义
};

int main()
{
    sheeptuo st;
    std::cout << st.age << std::endl;
    std::cout << st.sheep::age << std::endl;
}

std::vector<Base&> v{};

 std::vector<Base*> v{};

class animal
{
    public:
    virtual void func()    //这里需要加virtual关键字，这样子类才会重写这个函数，如果没有使用virtual的话就会输出animal
    {
        std::cout << "animal" << std::endl;
    }
};

class cat:public animal
{
    public:
    void func()
    {
        std::cout << "cat" << std::endl;
    }
};

class dog:public animal
{
    public:
    void func()
    {
        std::cout << "dog" << std::endl;
    }
};

void func(animal& animal)    //这里需要使用引用或者指针，因为使用动态多态时需要对类进行实例化，如果没有使用引用的话就找不到子类的地址，这样就会输出父类中的函数
{
    animal.func();
}

int main()
{
    dog d;
    func(d);

    return 0;
}

class Animal
{
public :
    virtual void shout() = 0;
};

class Dog :public Animal
{
public:
    virtual void shout(){ cout << "汪汪！"<<endl; }
};

class Cat :public Animal
{
public:
    virtual void shout(){ cout << "喵喵~"<<endl; }
};

class Bird : public Animal
{
public:
    virtual void shout(){ cout << "叽喳!"<<endl; }
};

int main()
{
    Animal * anim1 = new Dog;    //运行时在堆区申请内存
    Animal * anim2 = new Cat;
    Animal * anim3 = new Bird;

   //由指针（或引用）调用的接口，在运行期确定指针（或引用）所指对象的真正类型，调用该类型对应的接口
    anim1->shout();
    anim2->shout();
    anim3->shout();

    //delete 对象
   return 0;
}

virtual void func() = 0;    //纯虚函数写法

struct Pet {
    virtual void speak() = 0;
};

struct CatPet ：Pet {
    void speak() override {
        puts("喵");
    }
};

struct DogPet ：Pet {
    void speak() override {
        puts("汪");
    }
};

int main() {
    Pet *cat = new CatPet();    //注意这个写法，将子类对象的指针赋值给父类对象的指针
    Pet *dog = new DogPet();
    cat->speak();    //然后就可以使用 子类对象->父类纯虚函数 调用子类重写后的方法了
    dog->speak();
}

template <typename T>    //除了typename外还可以使用class，这两个没有区别，只是使用习惯不同
void myswap(T &a, T &b) //不能将函数名改为swap，这会导致call of overloaded 'swap(int&, int&)' is ambiguous错误，这意味着自定义函数名与系统库的函数名冲突
{
    T temp = a;
    a = b;
    b = temp;
}

int main()
{
    int a = 10;
    int b = 20;
    myswap(a, b);
    //myswap<int>(a, b);    //显式调用模板
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    return 0;
}

template <typename T>
void myswap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

int main()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    myswap<int>(a, c);    //显式调用模板产生隐式类型转换
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    return 0;
}

myswap<>(a,c);    //空模板列表

#include <iostream>
#include <string>
using namespace std;

// 自定义 person 类
class person {
public:
    string name;
    int age;
};

// 通用模板（适用于一般类型）
template <typename T>
bool my_compare(const T& a, const T& b) {
    return a == b;  // 依赖类型的 == 运算符
}

// 特化版本（专门用于 person 类型）
template<>
bool my_compare<person>(const person &p1, const person &p2) {
    return (p1.name == p2.name && p1.age == p2.age);
}

int main() {
    person p1 = {"Alice", 25};
    person p2 = {"Alice", 25};
    person p3 = {"Bob", 30};

    cout << my_compare(p1, p2) << endl;  // true（name 和 age 相同）
    cout << my_compare(p1, p3) << endl;  // false（name 不同）

    int x = 10, y = 10;
    cout << my_compare(x, y) << endl;    // true（调用通用模板）
    return 0;
}

#include <iostream>
#include<string>
using namespace std;

template <class nametype, class agetype>
class person
{
    public:
    person(nametype name, agetype age)
    {
        this->name = name;
        this->age = age;
    }
    void showperson()
    {
        std::cout << name << std::endl;
        std::cout << age << std::endl;
    }
    nametype name;
    agetype age;
};

int main()
{
    person<string,int> p1("xiaoming",14);   //注意对象实例化
    p1.showperson();
    return 0;
}

template <class nametype = string, class agetype = int>    //指定默认参数
class person
{
    public:
    person(nametype name, agetype age)
    {
        this->name = name;
        this->age = age;
    }
    void showperson()
    {
        std::cout << name << std::endl;
        std::cout << age << std::endl;
    }
    nametype name;
    agetype age;
};

int main()
{
    person p1("xiaoming",14);
    p1.showperson();
    return 0;
}

template <class nametype, class agetype>
class person
{
    public:
    person(nametype name, agetype age)
    {
        this->name = name;
        this->age = age;
    }
    void showperson()
    {
        std::cout << name << std::endl;
        std::cout << age << std::endl;
    }
    nametype name;
    agetype age;
};

void showperson2(person<string,int> p)    //类模板作为函数参数
{
    p.showperson();
    std::cout << "p2.name: " << p.name << std::endl;
}

int main()
{
    person<string,int>p1("xiaoming",14);
    showperson2(p1);
    return 0;
}

template <class nametype, class agetype>
class person
{
    public:
    person(nametype name, agetype age)
    {
        this->name = name;
        this->age = age;
    }
    void showperson()
    {
        std::cout << name << std::endl;
        std::cout << age << std::endl;
    }
    nametype name;
    agetype age;
};

class son1: public person<string,int>    //注意要给出模板参数列表
{

};

template<class T1, class T2, class T3>
class son2: public  person<T1,T2>    // 将父类模板的参数列表模板化
{
    T3 obj;
};

#include <iostream>
#include <string>
using namespace std;

template <class nametype, class agetype>
class person
{
    public:
    person(nametype name, agetype age);    //这里给出声明，实现在下面
    // {
    //     this->name = name;
    //     this->age = age;
    // }
    void showperson()
    {
        std::cout << name << std::endl;
        std::cout << age << std::endl;
    }
    void showpersonname();
    nametype name;
    agetype age;
};

//注意类模板的写法
template <class nametype, class agetype>    //先利用类模板定义nametype
person<nametype, agetype>::person(nametype name, agetype age)    //再写好作用域，并且后面要跟上类模板的参数列表，即使用不到参数也必须给出，因为这是模板的类型
{
    this->name = name;
    this->age = age;
}

template <typename T1, typename T2>
void person<T1,T2>::showpersonname()
{
    std::cout << name << std::endl;
}

int main()
{
    person<string,int>p1("xiaoming",14);
    //p1.showperson();
    //showperson2(p1);
    p1.showpersonname();
    return 0;
}

//person.h
template <class nametype, class agetype>
class person
{
    public:
    person(nametype name, agetype age);
    // {
    //     this->name = name;
    //     this->age = age;
    // }
    void showperson()
    {
        std::cout << name << std::endl;
        std::cout << age << std::endl;
    }
    void showpersonname();
    nametype name;
    agetype age;
};

//person.cpp
#include "person.h"
template <class nametype, class agetype>
person<nametype, agetype>::person(nametype name, agetype age)
{
    this->name = name;
    this->age = age;
}

template <typename T1, typename T2>
void person<T1,T2>::showpersonname()
{
    std::cout << name << std::endl;
}

//main.cpp
#include "person.h"
int main()
{
    person<string,int>p1("xiaoming",14);
    //p1.showperson();
    //showperson2(p1);
    p1.showpersonname();
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

void print(vector<int> &v)
{
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++)    //注意迭代器写法
    {
        std::cout << (*it) << " ";
    }
    std::cout << endl;
}

void test()
{
    int i;
    vector<int> v1;    //无参构造赋值
    for(i = 0; i < 10; i++)
    {
        v1.push_back(i);
    }
    print(v1);

    vector<int> v2 = v1;    //重载运算符赋值(调用到vector提供的重载函数)
    print(v2);

    vector<int> v3(v1);    //拷贝构造函数赋值
    print(v3);
}

int main()
{
    test();
    return 0;
}

empty()    //判断容器是否为空
capacity()    //获取当前容器中的最大容量，超过此值会导致realloc
size()    //获取当前容器中元素的个数
shrink_to_fit()    //删除元素后调用，可以释放被占用的内存
resize(int num)    //重新指定容器大小，比原来大就用默认值填充容器，比原来小将容器末尾元素舍去
push_back(element)    //尾部添加一个元素element
pop_back()    //尾部删除一个元素
insert(const_iterator pos, element)    //在pos位置插入元素element
erase(const_iterator pos)    //在pos位置删除元素
clear()    //删除容器内所有元素
at(int index)    //返回指定下标的元素
operator[]    //同上
front()    //返回容器内第一个元素
back()    //返回容器内最后一个元素

push_front(element)    //头部添加一个元素element
pop_front()    //头部删除一个元素

push(element)    //向栈顶添加元素
pop()    //从栈顶移除第一个元素
top()    //返回栈顶元素但并不移除
empty()    //判断栈是否为空
size()    //返回栈的大小

push(element)    //从队尾添加元素
pop()    //从队头移除第一个元素
back()    //查看队尾元素
front()    //查看对头元素
empty()    //判断队列是否为空
size()    //返回队列的大小

erase(const_iterator pos)    //在pos位置删除元素
remove(element)    //删除容器中所有与element值匹配的元素
reverse()    //反转排序
sort()    //排序函数，默认从小到大

list<int> l;
l.sort()    //默认排序从小到大

find(key)    //查找key是否存在，若存在，返回该元素的迭代器，若不存在，返回set.end()
count(key)    //查找key是否存在

class mycompare
{
    public:
    bool operator()(int val1, int val2)    //重载仿函数
    {
        return val1 > val2;
    }
};

int main()
{
    set<int,mycompare> s;    //在此处传入回调函数
}

class person
{
    public:
    person(string name, int age)
    {
        this->name = name;
        this->age = age;
    }
    
    string name;
    int age;
};

class mycompare
{
    public:
    bool operator()(const person val1, const person val2)
    {
        return val1.age > val2.age;
    }
};

int main()
{
    set<person,mycompare> s;
   /* todo */
}

#include <utility>
pair<type,type> p(typeval1,typeval2);
pair<type,type> p = make_pair(typeval1,typeval2)

for_each(iterator begin(), iterator end(), pred);

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

void print1(int val)
{
    cout << val << " ";
}

class print2
{
    public:
    void operator()(int v1)
    {
        cout << v1 << " ";
    }
};

void test()
{
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(50);
    v1.push_back(40);
    v1.push_back(20);
    v1.push_back(30);

    for_each(v1.begin(),v1.end(),print1);    //传入函数地址
    for_each(v1.begin(),v1.end(),print2());    //传入函数对象，必须加括号

    cout << endl;

}

int main()
{
    test();
}

transform(iterator src_begin(), iterator src_end(), iterator des_begin(), pred);

#include <iostream>
#include <vector>
#include <algorithm>  // transform

int main() {
    std::vector<int> src = {1, 2, 3, 4, 5};
    std::vector<int> des(src.size());  // 必须提前分配空间

    // 对 src 的每个元素 +1，结果存入 des
    std::transform(
        src.begin(), src.end(),  // 源范围
        des.begin(),             // 目标起始位置
        [](int x) { return x + 1; }  // 转换函数（Lambda）
    );

    // 输出 des: 2 3 4 5 6
    for (int x : des) std::cout << x << " ";
    return 0;
}

container<type>::iterator it = find(iterator begin(), iterator end(), pred);