auto
类型推导；让编译器在编译期就推导出变量的类型。
decltype
decltype则⽤于推导表达式类型，这⾥只⽤于编译器分析表达式的类型，表达式实际不会进⾏运算
智能指针
shared_ptr
采用引用计数器的方法，允许多个智能指针指向同一个对象，每当多一个指针指向该对象时，指向该对象的所有智能指针内部的引用计数加1，每当减少一个智能指针指向对象时，引用计数会减1，当计数为0的时候会自动释放动态分配的资源。
智能指针将一个计数器与类指向的对象相关联，引用计数器跟踪共有多少个类对象共享同一指针
每次创建类的新对象时，初始化指针并将引用计数置为1；
当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数。
对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象）并增加右操作数所指对象的引用计数；
调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）
- 同⼀个shared_ptr被多个线程“读”是安全的;
- 同⼀个shared_ptr被多个线程“写”是不安全的;
- 共享引⽤计数的不同的shared_ptr被多个线程”写“ 是安全的。
std::shared_ptr<Test> ptr1(new Test());
std::shared_ptr<Test> ptr2 = ptr1;
ptr1->test();
// 当ptr1和ptr2离开作用域时，他们指向的对象会被自动销毁
std::shared_ptr<A> sp2 = std::make_shared<A>();
shared_ptr对象包含了两个成员变量：一个指向被管理对象的原始指针，一个指向引用计数块的指针。
手写一个shared_ptr
// 实现计数部分
class SharedCount {
public:
SharedCount() : count_{1} {}
void add() { ++count_;}
void minus() { --count_; }
int get() const { return count_; }
private:
std::atomic<int> count_;
};
// 实现指针类
template <typename T>
class SharedPtr {
public:
SharedPtr(T* ptr) : ptr_{ptr}, ref_count_{new SharedCount} {}
SharedPtr() : ptr_{nullptr}, ref_count_{new SharedCount} {}
public:
~SharedPtr() { clean();}
private:
T* ptr_;
SharedCount* ref_count_;
private:
void clean() {
if(ref_count_) {
ref_count_->minus();
if(ref_count_->get() == 0) {
if(ptr_) delete ptr_;
delete ref_count_;
}
}
}
public:
SharedPtr(const SharedPtr& p) {
this->ptr_ = p.ptr_;
this->ref_count_ = p.ref_count_;
ref_count_->add();
}
SharedPtr& operator=(const SharedPtr& p) {
if(&p == this) return *this;
clean();
this->ptr_ = p.ptr_;
this->ref_count_ = p.ref_count_;
ref_count_->add();
return *this;
}
};
unique_ptr
unique_ptr采用的是独享所有权语义，一个非空的unique_ptr总是拥有它所指向的资源。转移一个unique_ptr将会把所有权全部从源指针转移给目标指针，源指针被置空；所以unique_ptr不支持普通的拷贝和赋值操作，不能用在STL标准容器中；局部变量的返回值除外（因为编译器知道要返回的对象将要被销毁）；如果你拷贝一个unique_ptr，那么拷贝结束后，这两个unque_ptr都会指向相同的资源，造成在结束时对同一内存指针多次释放而导致程序崩溃。
std::unique_ptr<Test> ptr(new Test());
ptr->test();
auto ptr2 = std::make_unique<int>(20);
为什么unique_ptr可以做到不可复制，只可移动？
下面是其源码。
template <typename _Tp, typename _Tp_Deleter = default_delete<_Tp> >
class unique_ptr {
// Disable copy from lvalue.
unique_ptr(const unique_ptr&) = delete;
template<typename _Up, typename _Up_Deleter>
unique_ptr(const unique_ptr<_Up, _Up_Deleter>&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
template<typename _Up, typename _Up_Deleter>
unique_ptr& operator=(const unique_ptr<_Up, _Up_Deleter>&) = delete;
};
可以发现，其拷贝构造函数和赋值运算符都被直接标记为了delete。
weak_ptr
弱引用。引用计数有一个问题就是互相引用形成环（环形引用），这样两个指针指向的内存都无法释放。需要使用weak_ptr打破环形引用。weak_ptr是一个弱引用，它是为了配合shared_ptr而引入的一个智能指针，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是说，它只引用，不计数。如果一块内存被shared_ptr和weak_ptr同时引用，当所有shared_ptr析构了之后，不管还有没有weak_ptr引用该内存，内存也会被释放。所以weak_ptr不保证它指向的内存一定是有效的，在使用之前使用函数lock()检查weak_ptr是否我空指针。
std::shared_ptr<Test> sharedPtr(new Test());
std::weak_ptr<Test> weakPtr = sharedPtr;
if(auto lockedSharedPtr = weakPtr.lock()) {
lockedSharedPtr->test();
}
空指针
nullptr是⽤来代替NULL，⼀般C++会把NULL、0视为同⼀种东⻄，这取决去编译器如何定义NULL，有的定义为 ((void*)0)，有的定义为0 C++不允许直接将void* 隐式转换到其他类型，在进⾏C++重载时会发⽣混乱。
如果NULL被定义为 ((void*)0)，那么当编译char *ch = NULL时，NULL被定义为 0 当foo(NULL)时，此时NULL为0，会去调⽤foo(int )，从⽽发⽣混乱 为解决这个问题，从⽽需要使⽤NULL时，⽤nullptr代替： C++11引⼊nullptr关键字来区分空指针和0。nullptr 的类型为 nullptr_t，能够转换为任何指针或成员指针的类型， 也可以进⾏相等或不等的⽐较。
基于范围的for循环
基于范围的迭代写法，for（变量：对象）表达式
对string对象的每个字符做⼀些操作：
string str ("some thing");
for (char c : str) cout << c << endl; // 输出字符串str中的每个字符
对vector中的元素进行遍历：
std::vector<int> arr(5, 100);
for (std::vector<int>::iterator i = arr.begin(); i != arr.end(); i ++) {
std::cout << *i << std::endl;
}
// 范围for循环
for (auto &i : arr) {
std::cout << i << std::endl;
}
右值引用和move语义
右值引用
- 左值： 可以放在等号左边，可以取地址并有名字；可以取地址有名字的就是左值
- 右值： 不可以放在等号左边，不能取地址，没有名字；不能取地址没有名字的就是右值
左值引用：
对于左值的引用，等号右边的值必须可以取地址，如果不能取地址，则会编译失败，或者可以使用const引用形式，但这样就只能通过引用来读取输出，不能修改数组，因为是常量引用。
int a = 5;
int &b = a; // b是左值引用
b = 4;
int &c = 10; // error，10无法取地址，无法进行引用
const int &d = 10; // ok，因为是常引用，引用常量数字，这个常量数字会存储在内存中，可以取地址
右值引用：
对一个临时对象或者即将销毁的对象的引用，开发者可以利用这些临时对象，却不需要复制它们。如果使用右值引用，那表达式等会右边的值需要是右值，可以使用std::move函数强制把左值转换为右值。
int a = 4;
int &&b = a; // error, a是左值
int &&c = std::move(a); // ok
正则表达式
Lambda表达式
lambda表达式表示⼀个可调⽤的代码单元，没有命名的内联函数，不需要函数名因为我们直接（⼀次性的）⽤ 它，不需要其他地⽅调⽤它。
[capture list] (parameter list) -> return type {function body }
// [捕获列表] (参数列表) -> 返回类型 {函数体 }
// 只有 [capture list] 捕获列表和 {function body } 函数体是必选的
auto lam =[]() -> int { cout << "Hello, World!"; return 88; };
auto ret = lam();
cout<<ret<<endl; // 输出88
-> int ：代表此匿名函数返回int，⼤多数情况下lambda表达式的返回值可由编译器猜测得出，因此不需要我们指 定返回值类型。
移动语义
一种优化资源管理的机制，常规的资源管理是拷贝别人的资源，而移动语义是转移所有权，转移了资源而不是拷贝资源。移动语义通常用于那些比较大的对象。
class A {
public:
A(int size) : size_(size) {
data_ = new int[size];
}
A(){}
A(const A& a) {
size_ = a.size_;
data_ = new int[size_];
cout << "copy " << endl;
}
A(A&& a) {
this->data_ = a.data_;
a.data_ = nullptr;
cout << "move " << endl;
}
~A() {
if (data_ != nullptr) {
delete[] data_;
}
}
int *data_;
int size_;
};
int main() {
A a(10);
A b = a;
A c = std::move(a); // 调用移动构造函数
return 0;
}
如果不适用std::move，会有很大的拷贝代价。
完美转发
指可以写一个接受任意实参的函数模板，并转发到其它函数，目标函数会收到与转发函数完全相同的实参，转发函数实参是左值那目标函数实参也是左值，转发函数实参是右值那目标函数实参也是右值。
用std::forward
void PrintV(int &t) {
cout << "lvalue" << endl;
}
void PrintV(int &&t) {
cout << "rvalue" << endl;
}
template<typename T>
void Test(T &&t) {
PrintV(t);
PrintV(std::forward<T>(t));
PrintV(std::move(t));
}
int main() {
Test(1); // lvalue rvalue rvalue
int a = 1;
Test(a); // lvalue lvalue rvalue
Test(std::forward<int>(a)); // lvalue rvalue rvalue
Test(std::forward<int&>(a)); // lvalue lvalue rvalue
Test(std::forward<int&&>(a)); // lvalue rvalue rvalue
return 0;
}
- Test(1)：1是右值，模板中T&&t这种为万能引用，右值1传到Test函数中变成了右值引用，但是调用PrintV()时候，t变成了左值，因为它变成了一个拥有名字的变量，所以打印了lvalue，而PrintV(std::forward<T>(t))时候，会进行完美转发，按照原来的类型转发，所以打印rvalue，PrintV(std::move(t))毫无疑问会打印rvalue。
- Test(a)：a是左值，模板中T&&这种为万能引用，左值a传到Test函数中变成了左值引用，所以有代码中打印。
- Test(std::forward<T>(a))：转发为左值还是右值，依赖于T，T是左值那就是转发为左值，T是右值那就转发为右值。
扫一扫
843
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
