Some tips in C++

#include<condition_variable>
class RWMutex {
public:
    RWMutex() : counter_(0), waiting_readers_(0), waiting_writers_(0) {}
    ~RWMutex() = default;
    RWMutex(const RWMutex &) = delete;
    RWMutex(RWMutex &&) = delete;
    RWMutex& operator=(const RWMutex &) = delete;
    RWMutex& operator=(RWMutex &&) = delete;
    int counter_;  // 全局控制
    int waiting_readers_;
    int waiting_writers_;
    std::mutex mutex_;  // 全局
    std::condition_variable reader_cv_;
    std::condition_variable writer_cv_;
};
class ReadLock {
public:
    explicit ReadLock(RWMutex* rw_mutex) : rw_mutex_(rw_mutex)
    {
        assert(rw_mutex != NULL);
        std::unique_lock<std::mutex> lock(rw_mutex->mutex_);
        rw_mutex_->waiting_readers_ += 1;
        rw_mutex_->reader_cv_.wait(lock, [&]() -> bool {  // 写者优先，counter_>=0表示没有人在写
        // 当读写锁处于读模式锁住状态时, 如果有另外线程试图以写模式加锁, 读写锁通常会阻塞随后的读模式锁请求, 这样可以避免读模式锁长期占用, 而等待的写模式锁请求长期阻塞.
           return rw_mutex_->waiting_writers_ == 0 && rw_mutex_->counter_ >= 0;
        });
        rw_mutex_->waiting_readers_ -= 1;
        rw_mutex_->counter_ += 1;
    }
    ~ReadLock() {
        std::unique_lock<std::mutex> lock(rw_mutex_->mutex_);
        rw_mutex_->counter_ -= 1;
        if (rw_mutex_->waiting_writers_ > 0) {
            if (rw_mutex_->counter_ == 0) {  // 有人等写，而且没有人在读/写
                rw_mutex_->writer_cv_.notify_one();
            }
        }
    }
    ReadLock(const ReadLock &) = delete;
    ReadLock(ReadLock &&) = delete;
    ReadLock& operator=(const ReadLock &) = delete;
    ReadLock& operator=(ReadLock &&) = delete;
private:
    RWMutex* rw_mutex_;
};
class WriteLock {
public:
    explicit WriteLock(RWMutex* rw_mutex) : rw_mutex_(rw_mutex) {
        assert(rw_mutex != NULL);
        std::unique_lock<std::mutex> lock(rw_mutex->mutex_);
        rw_mutex_->waiting_writers_ += 1;
        rw_mutex_->writer_cv_.wait(lock, [&]() -> bool {  // 没有别人读&写时候，才可以写
            return rw_mutex_->counter_ == 0;
        });
        rw_mutex_->waiting_writers_ -= 1;  // 拿到了写权利
        rw_mutex_->counter_ -= 1;
    }
    ~WriteLock() {
        std::unique_lock<std::mutex> lock(rw_mutex_->mutex_);
        rw_mutex_->counter_ = 0;
        if (rw_mutex_->waiting_writers_ > 0) {  // 优先写
            rw_mutex_->writer_cv_.notify_one();
        } else {
            rw_mutex_->reader_cv_.notify_all();
        }
    }
    WriteLock(const WriteLock &) = delete;
    WriteLock(WriteLock &&) = delete;
    WriteLock& operator=(const WriteLock &) = delete;
    WriteLock& operator=(WriteLock &&) = delete;
private:
    RWMutex* rw_mutex_;
};

class A {
public:
    A(int a = 2) {  // 2. 其次初始化
        // a为此函数局部变量，并不是this->a(作用域被覆盖)
        a = 3;  // 3. 再次初始化
    }
    int a = 4;  // 1. 首先初始化
};
int main(int argc, const char * argv[]) {
    A a;
    std::cout << a.a << std::endl;  // a.a输出4
    return 0;
}
// 改变1: 局部变量改为aa，
A(int aa = 2) {
    a = 3;  // a.a输出3，此时a就是this->a
}
// 改变2: 用初始化列表
A(int a = 2):a(a) {  // 等同于this->a(a)
    a = 3;  // a.a输出2，初始化列表起作用
}
// 改变3: 用构造函数体
A(int a = 2):a(a) {
    this->a = 3;  // a.a输出3，构造函数体起作用，这是第3个初始化的位置
}

// raw string可以跨越多行，其中的空白和换行符都属于字符串的一部分。
std::cout <<R"(\n  // 注释也输出
    Hello,
    world!
    )" << std::endl;
// 结果：
\n  // 注释也输出
    Hello,
    world!

const int b = 10;
// b = 11 编译报错，因为b是一个常量对象
int * pc = const_cast<int *>(&b);
*pc = 11;
cout << "*pc = " << *pc << endl; //11， b原来地址的数据现在可由*pc来改变，即解除const
cout << "b = " << b << endl;  //10， b其实类似(编译器处理问题)#define b 10，没有变。但是xcode调试器给出的是11

// 如下的定义放到hpp中：
const std::string aa = "haha";
const char aaa='a';
const char a[] = R"(haha)";
const char * const aaaa = R"(haha)";
static const char * aaaaa = R"(haha)";
const char * aaaaaa = R"(haha)";  // 以上都对，这个不对！！！aaaaaa是个普通变量，还不是const的

class Person{
public:
    Person(string& name);
    string name() const;
private:
    class PersonImpl;
    shared_ptr<PersonImpl> pImpl;
};
Person::Person(string& name): pImpl(new PersonImpl(name)){}
string Person::name(){
    return pImpl->name();
}