豌豆

C++ 构造函数漫谈(四)

2019/08/21 1,995

这一章谈 C++11 中引入的两种 “语法糖” .使用它们可以使得我们的代码更为简洁优雅。

委托构造函数

在同一个类中，一个构造函数可以调用另一个构造函数，这叫委托构造函数。这是 C++ 11 的新特性。
委托构造函数可以简化在每个构造函数中的重复代码。

class B{
public:
    B():x_(0),y_(0),z_(0){
        //Do something
    }
    B(int x): B(){
        x_ = x;
    }

    B(int x, int y): B(x){
        y_ = y;
    }

    void DoSomething(){}
private:
    int x_;
    int y_;
    int z_;
};

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

class B{

public:

B():x_(0),y_(0),z_(0){

//Do something

}

B(int x): B(){

x_ = x;

}

B(int x, int y): B(x){

y_ = y;

}

void DoSomething(){}

private:

int x_;

int y_;

int z_;

};

注意一点，委托构造函数在使用时不可以形成环：禁止套娃。

继续阅读

Note c++

C++ 构造函数漫谈(三)

2019/08/19 2,008

这一章聊一聊在面向对象的C++中，构造函数的调用顺序。

数据成员的构造顺序

一个类的数据成员的初始化顺序只与其在类中的声明顺序相关，与其它无关。

而析构时，如果成员是在堆中，析构顺序正好与构造时相反。

class M {
 public:
  M(const char* msg) {
    cout << "M " << msg << endl;
    msg_ = new char[strlen(msg)+1];
    msg_[strlen(msg)] = '\0';
    strcpy(msg_, msg);
  }
  ~M() {
    cout << "~M " << msg_ << endl;
    delete msg_;
  }

 private:
  char* msg_;
};

class A {
 public:
  A() : pm2_(new M("pm2")), m2_("m2"), pm1_(new M("pm1")), m1_("m1") {}

 private:
  M m1_;
  M m2_;
  M* pm1_;
  M* pm2_;
};

int main() {
  A a;
  return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

class M {

public:

M(const char* msg) {

cout << "M " << msg << endl;

msg_ = new char[strlen(msg)+1];

msg_[strlen(msg)] = '\0';

strcpy(msg_, msg);

}

~M() {

cout << "~M " << msg_ << endl;

delete msg_;

}

private:

char* msg_;

};

class A {

public:

A() : pm2_(new M("pm2")), m2_("m2"), pm1_(new M("pm1")), m1_("m1") {}

private:

M m1_;

M m2_;

M* pm1_;

M* pm2_;

};

int main() {

A a;

return 0;

}

类A的成员的构造顺序为： m1_, m2_, pm1_, pm2_ 。析构时的顺序为 m2_, m1_ ,由于 pm1_, pm2_ 不在堆中，所以它们的析构需要类A自己管理。

继续阅读

Note c++

三五零法则

我们知道，编译器会为类自动生成几个特别的成员函数：构造函数、复制构造函数、复制赋值运算符、析构函数。后三者比较特殊，我们在下面会频繁提到。

三法则

若一个类需要用户显式定义析构函数、复制构造函数、复制赋值运算符中的一个，那么这三个函数都需要显式定义 。如果用户显式定义了其中一个，另外两个还是会被编译器隐式定义，这种混杂的情况容易生产无法预期的错误。
如果一个类中有非基本数据类型或者非类类型的成员(如指针、文件描述符等)，则这一法则表现的更为明显：隐式析构函数无法对这种成员进行有效的释放，隐式复制构造函数和隐式复制赋值运算符无法进行深拷贝。

继续阅读

Note c++

C++ 构造函数漫谈(一)

2019/08/12 2,789

C++ 构造函数有很多有意思的小细节。这里来做一些探讨。这些内容可能会分为几章，这一章来探讨隐式构造函数，显式空构造函数和 =default 修饰的构造函数，私有构造函数和 =delete 修饰的构造函数之间的区别。

在开始之前，我们先了解两种特殊的类：

聚合类与 POD

聚合类 是 C++ 中的一个特殊的类型。当一个类(class, struct, union) 满足以下条件时，它是一个聚合类：

无显式声明的构造函数(可以是 default 或 delete 的)
无基类
无虚成员函数
无私有的或受保护的非静态数据成员
无使用 {} 或 = 直接初始化的非静态数据成员

一个普通数组也是一种聚合类型(如 int[10], char[], double[2][3])

POD ( Plain old data structure ) 则是一种特殊的聚合类，它必须满足聚合类的所有条件，且不具有以下成员：

指针到成员类型的非静态数据成员(包括数组)。
非POD类类型的非静态数据成员(包括数组)。
引用类型的(reference type)非静态数据成员。
用户定义的拷贝与赋值算子。
用户定义的析构函数。

可见，POD类类型就是指class、struct、union，且不具有用户定义的构造函数、析构函数、拷贝算子、赋值算子；不具有继承关系，因此没有基类；不具有虚函数，所以就没有虚表；非静态数据成员没有私有或保护属性的、没有引用类型的、没有非POD类类型的（即嵌套类都必须是POD）、没有指针到成员类型的（因为这个类型内含了this指针）

POD 一般用来在不同的模块之前传递数据使用。如一个 C++ 库向外提供 C 接口，可以使用 POD 作为参数。

隐式构造函数，显式空构造函数和 `=default` 修饰的构造函数。

对于 未定义任何构造函数 的类型( struct class or union)，编译器会为该为自动生成一个 inline public 的构造函数, 如果这个类型满足 constexpr 类型的要求，则这个构造函数还会被 constexpr 修饰，这个由编译器生成的构造函数，我们称之为隐式构造函数或默认构造函数。在 C++11 以前，如果用户声明了其它构造函数，则编译器不会生成默认构造函数，需要我们显式的声明。而在 C++11 以后，我们仍可用 default 关键字来强制编译器自动生成原本隐式声明的默认构造函数。

继续阅读

Note c++

关于 enable_shared_from_this

2019/05/16 3,783

一. 引入

简单地说： enable_shared_from_this 是为了解决 在类的内部获取自己的 shared_ptr 这件事情而存在的。

众所周知，每一个对象都能通过this 指针来访问自己的地址。this 指针也是所有成员函数的隐含参数。然而有些时候，我们需要的不仅是 this，而是一个 “this的智能指针”。

这里有一个常见的场景：

class A {
public:
    A() :did_it_(false) {}
    ~A() {
        std::cout << "destoried" << std::endl;
    }

    void OnDo(bool did) {
        did_it_ = did;
        std::cout << "somthing did" << std::endl;
    }

    void DoSth_Async() {
        std::thread t([this]() {
            std::this_thread::sleep_for(std::chrono::seconds(5));
            //...do somthing
            OnDo(true);
        });
        t.detach();
    }
private:
    bool did_it_;
};

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

class A {

public:

A() :did_it_(false) {}

~A() {

std::cout << "destoried" << std::endl;

}

void OnDo(bool did) {

did_it_ = did;

std::cout << "somthing did" << std::endl;

}

void DoSth_Async() {

std::thread t([this]() {

std::this_thread::sleep_for(std::chrono::seconds(5));

//...do somthing

OnDo(true);

});

t.detach();

}

private:

bool did_it_;

};

代码如上：在异步方法 DoSth_Async() 中调用了成员方法 OnDo(bool) . 这里存在一个问题：当 OnDo() 被调用的时候，该类的是否还在生存中：

int main(){
    {
        std::shared_ptr<A> ptr(new A());
        ptr->DoSth_Async();
    }
    std::this_thread::sleep_for(std::chrono::seconds(5));
    return 0;
}

1

2

3

4

5

6

7

8

int main(){

{

std::shared_ptr<A> ptr(new A());

ptr->DoSth_Async();

}

std::this_thread::sleep_for(std::chrono::seconds(5));

return 0;

}

智能指针 ptr 在出作用域后立即被释放。所以当 OnDo() 被调用的时候，其所在的对象实际已经被释放了。如果确保在 OnDo() 被调用的时候，该对象仍然在生命周期内呢？一个方便的方法便上在构建线程的时候，将该对象的 shared_ptr 传入到线程。在该线程的生命周期内，该对象就会一直存在。这是一种利用 shared_ptr 的 保活机制 。

继续阅读

Note c++, c++11, enable_shared_from_this, shared_ptr

多线程编程中的一些原则

2018/03/19 3,395

关于 C++ 多线程编程一的些基本知识可以参考本博客的《C++11/14 新特性(多线程)》，《Unix线程基础》。本章不是多线程编程教程，而是个人经验的一些总结。这些经验有一些可能是不正确的，希望在今后的编程中实践、改进。

线程同步的四项基本原则：

最低限度地共享对象。对象尽量不要暴露给别的线程，如果需要暴露，优先考虑 immutable对象。否则尽量使用同步措施来充分地保护它
尽量使用高级地并发编程构件，如任务队列、生产者消费者模式等
只用非递归的互斥器和条件变量，慎用读写锁，尽量少用信号量
除了使用 atomic 整数外，不要自己编写 lock-free 代码，也不要用”内核级”同步原语

互斥器 Mutex

mutex 是最常用的同步原语，它保护一个临界区，任何时候最多只能有一个线程能够访问 mutex 保护的域。使用 mutex 主要是为了保护共享数据。一般原则有：

使用 RAII手法封装 mutex 的创建、销毁、加锁、解锁操作，充分保证锁的有效期等于其作用域，而不会因为中途返回或异常而忘记解锁。这类似于 Java 的synchronized 或 C# 的 using 语句。
使用非递归的 mutex
尽量不要人为地调用 lock() 和 unlock()函数，将这些操作交给栈上的 guard 对象，利用其构造与析构函数。
不要跨线程地加解锁，避免在不同的函数中分别加锁\解锁，避免在不同的语句分支中加锁\解锁
每当构造 guard 对象时，需要考虑栈上已有的锁，防止因加锁顺序不同而导致死锁
避免跨进程的 mutex, 进程间通讯尽量使用 TCP sockets

只使用非递归地 mutex

继续阅读

Note c++, thread, 多线程

using 关键字在 C++ 中的几种用法

2018/03/13 11,571

对C++中 using关键字的几种用法的总结：

1. using 声明

using 声明 (using declaration) 是将命名空间中单个名字注入到当前作用域的机制，使得在当前作用域下访问另一个作用域下的成员时无需使用限定符 ::

// ...
{
    using std::map
    map<int, std::string> the_map; //ok
}
map<int, std::string> the_map2;  //error

1

2

3

4

5

6

// ...

{

using std::map

map<int, std::string> the_map; //ok

}

map<int, std::string> the_map2; //error

using 声明将其它 namespace 的成员引入本命名空间的 当前作用域 (包括其嵌套作用域) 。一个 using 声明一次只引入一个命名空间成员，它使得无论程序中使用哪些名字，都非常准确。
利用 using 声明，可以改变派生类对父类成员的访问控制:

class Base{
protected:
    int bn1;
    int bn2;
};

class Derived: private Base{
public:
    using Base::bn1;
};

class DerivedAgain: public Derived{
};

int main(){
    Derived d;
    DerivedAgain da; 
    d.bn1 = 1;
    d.bn2 = 2; //error, 'bn2' is a private member of 'Base'
    da.bn1 = 3;  //ok
    std::cout<<d.bn1<<std::endl;

    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

class Base{

protected:

int bn1;

int bn2;

};

class Derived: private Base{

public:

using Base::bn1;

};

class DerivedAgain: public Derived{

};

int main(){

Derived d;

DerivedAgain da;

d.bn1 = 1;

d.bn2 = 2; //error, 'bn2' is a private member of 'Base'

da.bn1 = 3; //ok

std::cout<<d.bn1<<std::endl;

return 0;

}

尽管 Derived 对 base 是私有继承，但通过 using 声明，我们还是可以在 Derived 中访问其成员，且后续的继承同样不受 private 限定的影响。

继续阅读

Coding c++, c++11

C++11/14 新特性 (多线程)

2017/03/28 5,793

在 C++11 之前，C++ 标准并没有提供统一的并发编程标准，也没有提供语言级别的支持。这导致我们在编写可移植的多线程程序时很不方便，往往需要面向不同的平台进行不同的实现，或者引入一些第三方平台，如Boost,pthread_win32 等。从C++11开始，对并发编程进行了语言级别的支持，使用使用C++进行并发编程方便了很多。这里介绍C++11并发编程的相关特性。

1 线程

1.1 线程的创建

std::thread 的构造函数如下：

template< class Function, class... Args > 
explicit thread( Function&& f, Args&&... args );

1 2	template< class Function, class... Args > explicit thread( Function&& f, Args&&... args );

我们只需要提供线程函数或函数对象，即可以创建线程，并可以同时指定线程函数的参数。

#include <iostream>
#include <thread>
using namespace std;

void func(const string& str){
    cout<<str<<endl;
}

class FuncCls{
public:
    void operator()(){
        cout<<"Funcls called"<<endl;
    }
};

int main(void){
    thread t1(func,"Hello World");
    FuncCls fcls;
    thread t2(fcls);

    if(t1.joinable()){
        t1.join();
    }
    t2.join();
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

#include <iostream>

#include <thread>

using namespace std;

void func(const string& str){

cout<<str<<endl;

}

class FuncCls{

public:

void operator()(){

cout<<"Funcls called"<<endl;

}

};

int main(void){

thread t1(func,"Hello World");

FuncCls fcls;

thread t2(fcls);

if(t1.joinable()){

t1.join();

}

t2.join();

return 0;

}

join函数将会阻塞线程，直到线程函数执行完毕，主线程才会接着执行。如果线程函数有返回值，返回值将被忽略。在使用线程对象的过程中，我们需要注意线程对象的生命周期。如果线程对象先于线程函数结束，那么将会出现不可预料的错误。可以通过线程阻塞的方式来等待线程函数执行完(join)，或让线程在后台执行。如果不希望线程被阻塞，可以调用线程的 detach() 函数，将线程与线程对象分离。但需要注意的是，detach 之后的线程无法再使用join来进行阻塞了，即detach之后的线程，我们无法控制了。当我们不确定一个线程是否可以join时，可以先使用 thead::joinable() 来进行判断。

另外，我们还可以通过 std::bind, lambda 来创建线程(其实就是使用函数对象创建线程)。

线程不可以被复制，但是可以被移动:
继续阅读

Coding c++, c++11, mutex, thread, 多线程

豌豆

存档

C++ 构造函数漫谈(四)

委托构造函数

C++ 构造函数漫谈(三)

数据成员的构造顺序

C++ 构造函数漫谈(二)

三五零法则

三法则

C++ 构造函数漫谈(一)

聚合类与 POD

隐式构造函数，显式空构造函数和 `=default` 修饰的构造函数。

关于 enable_shared_from_this

一. 引入

多线程编程中的一些原则

互斥器 Mutex

只使用非递归地 mutex

using 关键字在 C++ 中的几种用法

1. using 声明

C++11/14 新特性 (多线程)

1 线程

1.1 线程的创建

页面

近期文章

归档

分类

链接

存档

委托构造函数

数据成员的构造顺序

三五零法则

三法则

聚合类 与 POD

隐式构造函数，显式空构造函数 和 =default 修饰的构造函数。

一. 引入

互斥器 Mutex

只使用非递归地 mutex

1. using 声明

1 线程

1.1 线程的创建

页面

近期文章

归档

分类

标签

链接

聚合类与 POD

隐式构造函数，显式空构造函数和 `=default` 修饰的构造函数。