1、const
1）、常量
const一般的用法就是修饰变量、引用、指针，修饰之后它们就变成了常量，需要注意的是const并未区分出编译期常量和运行期常量，并且const只保证了运行时不直接被修改
一般的情况，const放在左边，表示常量：
const int x = 100; // 常量
const int& rx = x; // 常量引用
const int* px = &x; // 常量指针
给变量加上const之后变量就成了常量，只能读、禁止写，编译器会帮你检查出所有对它的写操作，发出警告，在编译阶段防止有意或者无意的修改。这样一来，const常量用起来就相对安全一点。所以在设计函数的时候，将参数用const修饰的话，一个是可以保证效率，另一个是保证安全
2）、修饰成员函数
除此之外，const还能声明在成员函数上，const被放在了函数的后面，表示这个函数是一个常量，函数的执行过程是const的，不会修改对象的状态（即成员变量），比如：
class DemoClass final {
private:
const long MAX_SIZE = 256; // const成员变量
int m_value; // 成员变量
public:
int get_value() const // const成员函数
{
// error: Cannot assign to non-static data member within const member function 'get_value'
m_value = 100;
return m_value;
}
};
3）、指针常量
const放在*的右边，表示指针是常量（const pointer to int），指针不能被修改，而指向的变量可以被修改：
int x = 100;
int b = 150;
int *const px = &x;
*px = 102; // success
px = &b; // error: Cannot assign to variable 'px' with const-qualified type 'int *const'
int *const px和const int* px的区别：
int *const px定义了一个指针常量，指针本身的地址不可改变，但可以改变指针所指向的数据const int* px定义了一个指向常量的指针，可以改变指针的地址使其指向其他int，但不能通过此指针修改所指向的int值
4）、小结
| const | 非const | |
| 对象（实例） | const T：对象只读，只能调用const成员函数 |
可以修改对象，调用任意成员函数 |
| 引用 | const T&：引用的对象只读，只能调用const成员函数 |
|
| 指针 | *const：指针指向的对象只读，只能调用const成员函数 |
|
| 成员函数 | func() const：不允许修改成员变量 |
可以修改成员变量 |
| 指针常量 | const T*：表示指针是常量，指针不能被修改，而其指向的变量可以被修改 |
指针和其指向的变量都可以被修改 |
2、智能指针
1）、unique_ptr
unique_ptr是一种独占资源所有权的指针，它会自动管理初始化时的指针，在离开作用域时析构释放内存
#include <iostream>
#include <memory>
int main() {
std::unique_ptr<int> ptr1(new int(10)); // int智能指针
assert(*ptr1 == 10); // 使用*取内容
assert(ptr1 != nullptr); // 判断是否为空指针
std::unique_ptr<std::string> ptr2(new std::string("hello")); // string智能指针
assert(*ptr2 == "hello"); // 使用*取内容
assert(ptr2->size() == 5); // 使用->调用成员函数
return 0;
}
在C++14的时候新加入了make_unique()函数，可以利用它构造一个unique_ptr对象：
#include <iostream>
#include <memory>
int main() {
auto ptr1 = std::make_unique<int>(42); // 工厂函数创建智能指针
assert(ptr1 && *ptr1 == 42);
auto ptr2 = std::make_unique<std::string>("god of war"); // 工厂函数创建智能指针
assert(!ptr2->empty());
return 0;
}
unique_ptr的所有权：
unique_ptr表示指针的所有权是唯一的，不允许共享，任何时候只能有一个人持有它
为了实现这个目的，unique_ptr应用了C++的转移（move）语义，同时禁止了拷贝赋值，所以，在向另一个unique_ptr赋值的时候，要特别留意，必须用std::move()函数显式地声明所有权转移
赋值操作之后，指针的所有权就被转走了，原来的unique_ptr变成了空指针，新的unique_ptr接替了管理权，保证所有权的唯一性：
#include <iostream>
#include <memory>
int main() {
auto ptr1 = std::make_unique<int>(42); // 工厂函数创建智能指针
assert(ptr1 && *ptr1 == 42); // 此时智能指针有效
auto ptr2 = std::move(ptr1); // 使用move()转移所有权
assert(!ptr1 && ptr2); // ptr1变成了空指针
return 0;
}
unique_ptr作为参数和返回值：
unique_ptr作为参数传递不会发生拷贝，但是会将对象所有权会转移到函数里，如下ptr会在main()方法结束之前被销毁：
#include <iostream>
#include <memory>
class Resource {
public:
Resource() { std::cout << "Resource acquired\n"; }
~Resource() { std::cout << "Resource destroyed\n"; }
friend std::ostream &operator<<(std::ostream &out, const Resource &res) {
out << "I am a resource";
return out;
}
};
void takeOwnership(std::unique_ptr<Resource> res) {
if (res) {
std::cout << *res << '\n';
}
} // Resource对象会在这里销毁
int main() {
auto ptr{std::make_unique<Resource>()};
// takeOwnership(ptr); // 不能这样写,unique_ptr禁止了拷贝赋值,需要使用std::move()函数显式地声明所有权转移
takeOwnership(std::move(ptr));
std::cout << "Ending program\n";
return 0;
}
输出：
Resource acquired
I am a resource
Resource destroyed
Ending program
有时候不想对象的所有权转移到函数里，这时候可以通过get()方法获取对象，如下：
#include <iostream>
#include <memory>
class Resource {
public:
Resource() { std::cout << "Resource acquired\n"; }
~Resource() { std::cout << "Resource destroyed\n"; }
friend std::ostream &operator<<(std::ostream &out, const Resource &res) {
out << "I am a resource";
return out;
}
};
void takeOwnership(Resource *res) {
if (res) {
std::cout << *res << '\n';
} else {
std::cout << "No resource\n";
}
}
int main() {
auto ptr{std::make_unique<Resource>()};
takeOwnership(ptr.get());
std::cout << "Ending program\n";
return 0;
} // Resource对象会在这里销毁
输出：
Resource acquired
I am a resource
Ending program
Resource destroyed
unique_ptr可以直接作为返回值返回：
#include <iostream>
#include <memory>
class Resource {
public:
Resource() { std::cout << "Resource acquired\n"; }
~Resource() { std::cout << "Resource destroyed\n"; }
friend std::ostream &operator<<(std::ostream &out, const Resource &res) {
out << "I am a resource";
return out;
}
};
std::unique_ptr<Resource> createResource() {
return std::make_unique<Resource>();
}
int main() {
auto ptr{createResource()};
return 0;
}
在C++14及之前的版本中会使用std::move来返回Resource对象，在C++17及以后版本中进行了RVO优化（https://en.wikipedia.org/wiki/Copy_elision），尽管没有显式使用std::move，编译器依然能够识别并优化这个返回过程，直接将新创建的Resource对象的所有权从createResource函数内部转移到了main函数中的ptr变量，而无需实际执行移动构造函数
2）、shared_ptr
shared_ptr和unique_ptr不同是它的所有权是可以被安全共享的，也就是说支持拷贝赋值，允许被多个人同时持有，就像原始指针一样
在底层实现中，shared_ptr采用引用计数的方式实现。引用计数最开始的时候是1，表示只有一个持有者。如果发生拷贝赋值——也就是共享的时候，引用计数就增加（为了保证并发安全，引用计数器的加1，减1操作都是原子操作），而发生析构销毁的时候，引用计数就减少。只有当引用计数减少到0，也就是说，没有任何人使用这个指针的时候，它才会真正调用delete释放内存
#include <iostream>
#include <memory>
class Resource {
public:
Resource() { std::cout << "Resource acquired\n"; }
~Resource() { std::cout << "Resource destroyed\n"; }
};
int main() {
auto ptr1 = std::make_shared<Resource>(); // 工厂函数创建智能指针
assert(ptr1 && ptr1.unique()); // 此时智能指针有效且唯一
{
auto ptr2 = ptr1; // 直接拷贝赋值,不需要使用move()
assert(ptr1 && ptr2); // 此时两个智能指针均有效
assert(ptr1 == ptr2); // shared_ptr可以直接比较
// 两个智能指针均不唯一,且引用计数为2
assert(!ptr1.unique() && ptr1.use_count() == 2);
assert(!ptr2.unique() && ptr2.use_count() == 2);
std::cout << "Killing one shared pointer\n";
} // ptr2离开了作用域,但是没有资源被销毁
assert(ptr1 && ptr1.unique()); // 此时智能指针有效且唯一
std::cout << "Killing another shared pointer\n";
return 0;
} // ptr1离开了作用域,Resource对象会在这里销毁
输出：
Resource acquired
Killing one shared pointer
Killing another shared pointer
Resource destroyed
在上面的例子中， ptr2在自己的作用域中被创建，然后出了作用域后ptr2虽然被销毁，但是所管理的资源却在main方法结束后才被销毁
enable_shared_from_this：
如果不小心直接在类里面返回this对象想要获得该对象的shared_ptr，那么会让一个对象被delete两次，如下：
#include <iostream>
#include <memory>
class Resource {
public:
Resource() { std::cout << "Resource acquired\n"; }
~Resource() { std::cout << "Resource destroyed\n"; }
std::shared_ptr<Resource> GetSPtr() {
return std::shared_ptr<Resource>(this);
}
};
int main() {
auto sptr1 = std::make_shared<Resource>();
auto sptr2 = sptr1->GetSPtr();
return 0;
}
输出：
Resource acquired
Resource destroyed
studyProject(6959,0x7ff854f04700) malloc: *** error for object 0x6000035ed1f8: pointer being freed was not allocated
studyProject(6959,0x7ff854f04700) malloc: *** set a breakpoint in malloc_error_break to debug
上面的代码其实会生成两个独立的shared_ptr，他们的控制块是独立的，所以导致Resource被释放了两次
使用enable_shared_from_this可以避免上述情况：
#include <iostream>
#include <memory>
class Resource : public std::enable_shared_from_this<Resource> {
public:
Resource() { std::cout << "Resource acquired\n"; }
~Resource() { std::cout << "Resource destroyed\n"; }
std::shared_ptr<Resource> GetSPtr() {
return shared_from_this();
}
};
int main() {
auto sptr1 = std::make_shared<Resource>();
auto sptr2 = sptr1->GetSPtr();
return 0;
}
shared_ptr的循环引用问题：
shared_ptr的引用计数也导致了一个新的问题，就是循环引用，这在把shared_ptr作为类成员的时候最容易出现，典型的例子就是链表节点
#include <iostream>
#include <memory>
class Node {
public:
using this_type = Node;
using shared_type = std::shared_ptr<this_type>;
Node(const std::string &name) : name(name) {
std::cout << name << " created\n";
}
~Node() {
std::cout << name << " destroyed\n";
}
std::string name;
shared_type next; // 使用智能指针来指向下一个节点
};
int main() {
auto n1 = std::make_shared<Node>("n1");
auto n2 = std::make_shared<Node>("n2");
assert(n1.use_count() == 1); // 引用计数为1
assert(n2.use_count() == 1);
n1->next = n2; // 两个节点互指,形成了循环引用
n2->next = n1;
assert(n1.use_count() == 2); // 引用计数为2
assert(n2.use_count() == 2); // 无法减到0,无法销毁,导致内存泄漏
return 0;
}
输出：
n1 created
n2 created
上面的代码中，两个节点指针刚创建时，引用计数是1，但指针互指（即拷贝赋值）之后，引用计数都变成了2
这个时候，shared_ptr意识不到这是一个循环引用，多算了一次计数，后果就是引用计数无法减到0，无法调用析构函数执行delete，最终导致内存泄漏
3）、weak_ptr
weak_ptr是专门为打破循环引用而设计，它实际上不会托管对象，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是将一个weak_ptr绑定到一个shared_ptr不会改变shared_ptr的引用计数。在需要的时候，可以调用weak_ptr的成员函数lock()，获取shared_ptr（强引用）
#include <iostream>
#include <memory>
class Node {
public:
using this_type = Node;
using shared_type = std::weak_ptr<this_type>; // 注意这里,别名改用weak_ptr
Node(const std::string &name) : name(name) {
std::cout << name << " created\n";
}
~Node() {
std::cout << name << " destroyed\n";
}
std::string name;
shared_type next;
};
int main() {
auto n1 = std::make_shared<Node>("n1");
auto n2 = std::make_shared<Node>("n2");
n1->next = n2; // 两个节点互指,形成了循环引用
n2->next = n1;
assert(n1.use_count() == 1); // 因为使用了weak_ptr,引用计数为1
assert(n2.use_count() == 1); // 打破循环引用,不会导致内存泄漏
if (!n1->next.expired()) { // 检查指针是否有效
auto ptr = n1->next.lock(); // lock()获取shared_ptr
assert(ptr == n2);
}
return 0;
}
输出：
n1 created
n2 created
n2 destroyed
n1 destroyed
4）、小结
unique_ptr是一种独占资源所有权的指针，它会在栈上分配，然后在离开作用域之后进行释放，删除里面持有的对象，它只能使用move语义转移对象。所以如果你想操作一个指针，在进入作用域的时候分配好内存，然后在离开作用域的时候安全释放对象，那么可以使用它
shared_ptr所管理的资源可以被多个对象持有，并且使用引用计数策略来释放对象，如果计数没有清零，那么它所管理的资源不会释放
weak_ptr不管理对象，只是shared_ptr对象管理的资源的观察者，所以它不影响共享资源的生命周期，它用于解决shared_ptr循环引用
3、lambda表达式
1）、lambda基本使用
#include <iostream>
int main() {
auto func = [](int x) // 定义一个lambda表达式
{
std::cout << x * x << std::endl; // lambda表达式的具体内容
};
func(3); // 调用lambda表达式
return 0;
}
C++里的lambda表达式除了可以像普通函数那样被调用，还有一个普通函数所不具备的特殊本领，就是可以捕获外部变量，在内部的代码里直接操作
#include <iostream>
int main() {
int n = 10; // 一个外部变量
auto func = [=](int x) // lambda表达式，用=捕获
{
std::cout << x * n << std::endl; // 直接操作外部变量
};
func(3); // 调用lambda表达式
return 0;
}
2）、使用lambda的注意事项
1）lambda的形式
嵌套定义lambda表达式
#include <iostream>
int main() {
auto f1 = []() // 定义一个lambda表达式
{
std::cout << "lambda f1" << std::endl;
auto f2 = [](int x) // 嵌套定义lambda表达式
{
return x * x;
}; // lambda f2
std::cout << f2(10) << std::endl;
}; // lambda f1
f1();
return 0;
}
匿名lambda表达式
#include <iostream>
int main() {
std::vector<int> v = {3, 1, 8, 5, 0}; // 标准容器
std::cout << *find_if(begin(v), end(v), // 标准库里的查找算法
[](int x) // 匿名lambda表达式,不需要auto赋值
{
return x >= 5; // 用做算法的谓词判断条件
}
)
<< std::endl; // 语句执行完,lambda表达式就不存在了
return 0;
}
2）lambda的变量捕获
lambda的变量捕获要点：
- [=]：表示按值捕获所有外部变量，表达式内部是值的拷贝，并且不能修改
- [&]：按引用捕获所有外部变量，内部以引用的方式使用，可以修改
- 可以在[]里明确写出外部变量名，指定按值或者按引用捕获
int main() {
int x = 33; // 一个外部变量
auto f1 = [=]() // lambda表达式,用=按值捕获
{
//x += 10; // x只读,不允许修改
};
auto f2 = [&]() // lambda表达式,用&按引用捕获
{
x += 10; // x是引用,可以修改
};
auto f3 = [=, &x]() // lambda表达式,用&按引用捕获x,其他的按值捕获
{
x += 20; // x是引用,可以修改
};
return 0;
}
3）泛型的lambda
在C++14里，lambda表达式可以实现泛型化，相当于简化了的模板函数
#include <iostream>
int main() {
auto f = [](const auto &x) // 参数使用auto声明,泛型化
{
return x + x;
};
std::cout << f(3) << std::endl; // 参数类型是int
std::cout << f(0.618) << std::endl; // 参数类型是double
std::string str = "matrix";
std::cout << f(str) << std::endl; // 参数类型是string
return 0;
}
3）、小结
- lambda表达式是一个闭包，能够像函数一样被调用，像变量一样被传递
- 可以使用auto自动推导类型存储lambda表达式，但C++鼓励尽量就地匿名使用，缩小作用域
- lambda表达式使用[=]的方式按值捕获，使用[&]的方式按引用捕获，空的[]则是无捕获（也就相当于普通函数）
- 捕获引用时必须要注意外部变量的生命周期，防止变量失效
- C++14里可以使用泛型的lambda表达式，相当于简化的模板函数
参考：
