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);

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;
}

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

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;    //错误，不能将常量赋值给b的内存区域，因为b这个引用指向的是常量区的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()(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;
}

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;
    ret = myadd()(1, 2);    //此时执行myadd的默认构造函数，但因为构造函数是空函数所以不起作用。因此只剩下匿名对象的运算符重载起作用了，返回值是3且当这行代码执行完毕后myadd匿名函数就会被系统回收
    std::cout << ret << std::endl;
    return 0;
}

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

class son: protected base
{
    a = 100;
    b = 200;
    c = 300;    //报错
}; 

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

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;
}

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;    //纯虚函数写法

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);    //空模板列表

template<> bool my_compare(person &p1, person &p2)//模板的重载
{
    if(p1.name == p2.name && p1.age == p2.age)
        return true;
    else
        return false;
}

#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>
using namespace std;
#include <vector>

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()    //获取容器的容量
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 */
}

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

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

#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(), funcclass fun);

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

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

container<type>::iterator it = adjacent_find(iterator begin(), iterator end()） 

sort(iterator begin(), iterator end(), pred)

merge(iterator container1_begin(), iterator container1_end(),iterator container2_begin(), iterator container2_end(), iterator dest_begin())

reverse(iterator begin(), iterator end())

copy(iterator begin(), iterator end(), iterator dest())

replace(iterator begin(), iterator end(), oldvalue, newvalue)

replace(iterator begin(), iterator end(), pred, newvalue)

swap(container c1, container c2)

replace(iterator begin(), iterator end(), value)    //第三个参数是起始的累加值，以应对有初始值的情况

container<type>::iterator it = set_intersection(iterator begin1(), iterator end1(), iterator begin2(), iterator end2(), iterator dest())

container<type>::iterator it = set_union(iterator begin1(), iterator end1(), iterator begin2(), iterator end2(), iterator dest())