从零开始学C++之对象的使用（三）：static 与单例模式、auto_ptr与单例模式、const 用法小结、mutable修饰符

最新推荐文章于 2022-03-16 21:38:52 发布

原创最新推荐文章于 2022-03-16 21:38:52 发布 · 5.8k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#static与单例模式 #const成员函数 #const对象 #mutable修饰符

从零开始学C++ 专栏收录该内容

52 篇文章

订阅专栏

本文介绍了C++中的单例模式，讲解了如何利用static解决对象生命周期问题，以及单例模式在多线程环境下的线程安全性。此外，还探讨了const成员函数、const对象的特性，并对const用法进行了总结，包括mutable修饰符的作用。

一、static 与单例模式

单例模式也就是简单的一种设计模式，它需要：

保证一个类只有一个实例，并提供一个全局访问点

禁止拷贝

    C++ Code 
 

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
33
34
35
36
37
38
39
40
41
42
43

#include <iostream>
using namespace std;

class Singleton
{
public:
     static Singleton *GetInstance()
    {
         if (instance_ == NULL)
        {
            instance_ = new Singleton;
        }
         return instance_;
    }

    ~Singleton()
    {
        cout << "~Singleton ..." << endl;
    }
private:
    Singleton( const Singleton &other);
    Singleton & operator=( const Singleton &other);
    Singleton()
    {
        cout << "Singleton ..." << endl;
    }
     static Singleton *instance_;
};

Singleton *Singleton::instance_;

int main( void)
{
     //Singleton s1;
     //Singleton s2;

    Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();

     //Singleton s3(*s1);        // 调用拷贝构造函数

     return 0;
}

上述程序虽然调用了两个GetInstance函数，但只调用一次构造函数，即创建一个对象。将赋值运算符和拷贝构造函数声明为私有，禁止拷贝。但程序存在一个问题就是对象生存期到时不会被析构。

为了解决对象不会被析构的问题，可以使用一个静态的嵌套类对象来解决：

    C++ Code 
 

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

#include <iostream>
using namespace std;

class Singleton
{
public:
     static Singleton *GetInstance()
    {
         if (instance_ == NULL)

{
instance_ = new Singleton;

}
return instance_;

    }

    ~Singleton()
    {
        cout << "~Singleton ..." << endl;
    }

     //static void Free()
     //{
     //  if (insta n ce_ != NULL)

// {
// delete insta n ce_;

     //  }
     //}

     class Garbo
    {
     public:
        ~Garbo()
        {
             if (Singleton::instance_ != NULL)

{
delete instance_;

            }
        }
    };
private:
    Singleton( const Singleton &other);
    Singleton & operator=( const Singleton &other);
    Singleton()
    {
        cout << "Singleton ..." << endl;
    }
     static Singleton *instance_;

static Garbo garbo_; // 利用对象的确定性析构
};

Singleton::Garbo Singleton::garbo_;
Singleton *Singleton::instance_;

int main( void)
{
     //Singleton s1;
     //Singleton s2;

    Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();

     //Singleton s3(*s1);        // 调用拷贝构造函数

     return 0;
}

利用静态嵌套对象的确定性析构会调用Garbo类的析构函数，在析构函数内delete 单例类的指针。

上面办法比较繁琐，也可以返回局部静态对象的引用来解决：

    C++ Code 
 

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
33
34
35

#include <iostream>
using namespace std;

class Singleton
{
public:
     static Singleton &GetInstance()
    {
         static Singleton instance;       // 局部静态对象
         return instance;
    }

    ~Singleton()
    {
        cout << "~Singleton ..." << endl;
    }

private:
    Singleton( const Singleton &other);
    Singleton & operator=( const Singleton &other);
    Singleton()
    {
        cout << "Singleton ..." << endl;
    }
};

int main( void)
{
    Singleton &s1 = Singleton::GetInstance();
    Singleton &s2 = Singleton::GetInstance();

     return 0;
}

局部静态对象只会初始化一次，所以调用多次GetInstance函数得到的是同一个对象。由于函数内使用了静态对象，故不是线程安全的。实际上也可以使用auto_ptr 智能指针来解决，程序如下，更详细的对auto_ptr 的讨论参见这里。

    C++ Code 
 

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
33
34
35
36
37
38
39
40
41
42
43
44

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

class Singleton
{
public:
     static Singleton *GetInstance()
    {
         if (instance_.get() == NULL)
        {
            instance_ = auto_ptr<Singleton>( new Singleton);
        }
         return instance_.get();
    }

    ~Singleton()
    {
        cout << "~Singleton ..." << endl;
    }
private:
    Singleton( const Singleton &other);
    Singleton & operator=( const Singleton &other);
    Singleton()
    {
        cout << "Singleton ..." << endl;
    }
     static auto_ptr<Singleton> instance_;
};

auto_ptr<Singleton> Singleton::instance_;

int main( void)
{
     //Singleton s1;
     //Singleton s2;

    Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();

     //Singleton s3(*s1);        // 调用拷贝构造函数

     return 0;
}

实际上，上述所有的单例模式例子都不是线程安全的，设想如果两个线程同时运行到语句if (instance == null)，而此时该实例的确没有创建，那么两个线程都会创建一个实例。如果不希望加锁实现线程安全，可以使用饿汉模式（即在main函数之前先生成一个实例）：

或者通过加锁方式实现，请参考这里。

二、const成员函数、const 对象、mutable修饰符

（一）、const 成员函数

const成员函数不会修改对象的状态

const成员函数只能访问数据成员的值，而不能修改它

（二）、const 对象

如果把一个对象指定为const，就是告诉编译器不要修改它
const对象的定义：

const 类名对象名(参数表);

const对象不能调用非const成员函数

用mutable修饰的数据成员即使在const对象或在const成员函数中都可以被修改。

    C++ Code 
 

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#include <iostream>
using namespace std;

class Test
{
public:
    Test( int x) : x_(x), outputTimes_( 0)
    {

    }
     int GetX() const
    {
        cout << "const GetX ..." << endl;
         //x_ = 100;
         return x_;
    }

     int GetX()
    {
        cout << "GetX ..." << endl;
         return x_;
    }

     void Output() const
    {
        cout << "x=" << x_ << endl;
        outputTimes_++;
    }

     int GetOutputTimes() const
    {
         return outputTimes_;
    }
private:
     int x_;

     mutable int outputTimes_;
};

int main( void)
{
     const Test t( 10);
    t.GetX();

    Test t2( 20);
    t2.GetX();

    t.Output();
    t.Output();
    cout << t.GetOutputTimes() << endl;
     return 0;
}