操作流

1

对象

成员函数与全局函数

成员函数的传递默认参数this

reference

const function和function const

return reference

构造函数

复合：由内到外

析构函数

复合：由外到内

拷贝构造

拷贝赋值

含有指针的赋值，希望可以拷贝一份(深拷贝)，而不是指向同一块内存区域(浅拷贝)

深拷贝:b=a；将a中的内容复制一份

浅拷贝:b=1;将b指向a的内容

image-20240125135919437

实例

实例的创建方式

实例的生存周期

临时对象

语法：typename()

1
2
class complex;
complex(1,2) ;//创建complex类的临时对象

using 关键字用于定义类型别名

1
using Ptr = std::shared_ptr<MediaSession>;//智能指针取别名

堆和栈

local:stack

static：程序结束释放

global:不在函数内部

static和global的区别

  1. 作用域

  2. 生命周期

堆区的对象(auto/local）离开作用域消失

静态数据

静态成员函数：静态函数没有this指针，不能去访问对象数据，只能处理对象的静态数据

1
2
3
4
5
6
7
class Account
{
    public :
    static double m_rate;
    static void set_rate(const double&x){m_rate=x;}
};
double Account::m_rate=8.0;

调用静态函数

  1. object调用

    1
    2
    Account a;
    a.set_rate(0.1);

  2. class name调用

    1
    Account::set_rate(0.1)

static的运用

只存在一个，不想再创建,外界只能通过getInstance获取实例，A::getInstance.setup();

1
2
3
4
5
6
7
8
class A{
    public A& getInstance{return a;}
    setuo(){};
    private:
    A();
    A(const A& rhs);
    static A a;
}

上面这个做法，如何用户是否调用A的实例，A的实例都会创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A{
    public A& getInstance();
    setup(){};

    private:
    A();
    A(const A& rhs);
};

A& A::getInstance()
{
    static A a;
    return a;
}

动态内存分类

new和free

new的过程

  1. 申请内存
  2. 类型转化
  3. 调用构造函数

new返回的是指针，调用的是malloc

free使用的是free

free的过程

  1. 调用析构函数
  2. 释放内存

new[ ]和delete[ ]

命名空间

防止命名冲突

1
2
namespace std{
}
1
using namespace std;

复合

1
2
3
4
5
6
class a;
class b{
    procted:
    class b;

}

a的实例由编译器自动创建

委托

1
2
3
4
5
6
class a;
class b
{
    private:
    a * a_point;
}

a的实例由开发者动态创建

继承

1
2
3
4
struct list_node:public _list_node_base
{

}

虚函数

虚函数和子类的复写有关

non-virtual：不复写

虚函数virtual function:可以override，父类有默认的定义

纯虚函数pree virtual function:一定要override，父类没有默认的定义

1

多态

模板

类模板

1
2
3
4
5
6
typlate<classname T>
class complex
{
    private:
    T re,im;
}

函数模板

1
2
3
4
5
template<class T>
const T& min(const T& a,const T& b)
{
    return b<a?b:a;
}

智能指针

unique_ptr

初始化

1
2
Perple p1=new People();
unique_ptr<Perple> uni_ptr(p1);//使用智能指针uni_ptr，托管普通指针p1
1
unique_ptr<People> uni_ptr(new People());//c14标准
1
unique_ptr<People> uni_ptr=make_nique<People>();

特点：不允许拷贝构造和复制函数，在函数传递中可以使用引用，但不能传递值

标准库

vector

pop

push

forward_list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
std::string multicast_ip_;
//可变数组
std::vector<NotifyConnectedCallback> notify_connected_callbacks_;
//原子类型
std::atomic_uint MediaSession::last_session_id_(1);
//单向链表
std::forward_list
//map
std::map<int, RtpPacket> packets; // 存储RtpPacket的映射表
//unordered_map
std::unordered_map<std::string, RtmpSession::Ptr> rtmp_sessions_; 
//智能互斥锁
std::lock_guard<std::mutex> lock(map_mutex_);
//产生真正随机数的设备类
std::random_device rd;