0715-----C++Primer听课笔记-----------函数指针 、单例模式

最新推荐文章于 2024-11-11 23:32:39 发布
最新推荐文章于 2024-11-11 23:32:39 发布
阅读量98 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/monicalee/p/3848057.html
版权

1.函数指针

1.1 普通成员函数指针包含类名信息以及const属性，指向具体函数是必须加上&符号。

#include <iostream>

using namespace std;

class Test{
    public:
        void setValue(const string &s, int a){
            s_ = s;
            a_ = a;
        }

        void print() const{
            cout << s_ << endl << a_ << endl;
        }
    private:
        string s_;
        int a_;
};

int main(int argc, const char *argv[])
{
    void (Test::*pfunc)(const string&, int) = &Test::setValue;
    void (Test::*pfunc1)()const = &Test::print;
    Test t;
    (t.*pfunc)("hello", 3);
    (t.*pfunc1)();

    Test *t1 = new Test;
    (t1->*pfunc)("hello", 3);
    (t1->*pfunc1)();

    delete t1;
    return 0;
}

1.2 static 函数指针不包含类名， & 符号也不是必须。

#include <iostream>

using namespace std;
class Test{
    public:
       static void print(){
            cout << "hello world " << endl;
        }
};

int main(int argc, const char *argv[])
{
    void(*funcPtr)() = &Test::print;
    funcPtr();
    return 0;
}

2.单例模式

2.1 将构造函数设为私有， 通过调用static 成员函数生成对象。此时通过多次调用static函数可以生成不同的对象。

#include <iostream>
#include <string>
#include <vector>
using namespace std;
/*
 *对象不唯一
 */

class Singleton{
    public:
        static Singleton *getInstance(){
            Singleton *ps = new Singleton;
            return ps;
        }

    private:
        Singleton(){}
};

int main(int argc, const char *argv[])
{
    Singleton *ps = Singleton::getInstance();
    cout << ps << endl;

    Singleton *ps2 = Singleton::getInstance();
    cout << ps2 << endl;
    return 0;
}

2.2  为解决上述对象不唯一问题， 设置一静态变量，通过判断是否为空，去生成对象，看似保证了唯一性。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

/*
 *多线程环境下存在竞态问题
 */

class Singleton{
    public:
        static Singleton *getInstance(){
            if(pInstance_ == NULL){
                pInstance_ = new Singleton;
            }
            return pInstance_;
        }
    private:
        Singleton(){}
        static Singleton *pInstance_;
};

Singleton *Singleton::pInstance_ = NULL;

int main(int argc, const char *argv[])
{
    Singleton *ps = Singleton::getInstance();
    cout << ps << endl;

    Singleton *ps2 = Singleton::getInstance();
    cout << ps2 << endl;
    return 0;
}

2.3 但是上述代码在多线程环境下存在竞态问题（if 语句处，多个线程同时进入时，可以生成不同的对象）。 如下所示。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

/*
 *多线程环境下存在竞态问题
 */

class Singleton{
    public:
        static Singleton *getInstance(){
            if(pInstance_ == NULL){
                sleep(2);
                pInstance_ = new Singleton;
            }
            return pInstance_;
        }
    private:
        Singleton(){}
        static Singleton *pInstance_;
};

Singleton *Singleton::pInstance_ = NULL;

void* threadFunc(void *arg){
    Singleton *ps = Singleton::getInstance();
    cout << ps << endl;
}

int main(int argc, const char *argv[])
{
    vector<pthread_t> vec(10);
    for(vector<pthread_t>::iterator it = vec.begin(); it != vec.end(); ++it){
        pthread_create(&*it, NULL, threadFunc, NULL);
    }
    for(vector<pthread_t>::iterator it = vec.begin(); it != vec.end(); ++it){
        pthread_join(*it, NULL);
    }
    return 0;
}

图像 4

 

2.4 为解决上述多线程竞态问题，我们每次检查指针前都上锁。这样就保证了对象在多线程环境下也是唯一的，如下所示。

#include <iostream>
#include <vector>
#include "mutexlock.h"
using namespace std;

/*
 *为了解决竞态问题 加锁
 */

class Singleton{
    public:
        static Singleton *getInstance(){
            mutex_.lock();
            if(pInstance_ == NULL){
                sleep(2);
                pInstance_ = new Singleton;
            }
            mutex_.unlock();
            return pInstance_;
        }
    private:
        Singleton(){}
        static Singleton *pInstance_;
        static Mutexlock mutex_;
};

/*
 *static 成员变量在类的内部是声明 必须在类的外部定义
 */
Singleton *Singleton::pInstance_ = NULL;
Mutexlock Singleton::mutex_;


void* threadFunc(void *arg){
    Singleton *ps = Singleton::getInstance();
    cout << ps << endl;
}

int main(int argc, const char *argv[])
{
    vector<pthread_t> vec(10);
    for(vector<pthread_t>::iterator it = vec.begin(); it != vec.end(); ++it){
        pthread_create(&*it, NULL, threadFunc, NULL);
    }
    for(vector<pthread_t>::iterator it = vec.begin(); it != vec.end(); ++it){
        pthread_join(*it, NULL);
    }
    return 0;
}

图像 5

2.4 上述程序每次获取对象都要加锁，造成了锁争用，使得效率降低，因此引用双重锁模式。

#include <iostream>
#include <vector>
#include "mutexlock.h"
using namespace std;

/*
 *每次调用都要征用锁 这是的效率降低
 * 因此 采用双重锁
 */

class Singleton{
    public:
        static Singleton *getInstance(){
            if(pInstance_ == NULL){
                mutex_.lock();
                if(pInstance_ == NULL){
                    sleep(2);
                    pInstance_ = new Singleton;
                }
                mutex_.unlock();
            }
            return pInstance_;
        }
    private:
        Singleton(){}
        static Singleton *pInstance_;
        static Mutexlock mutex_;
};

/*
 *static 成员变量在类的内部是声明 必须在类的外部定义
 */
Singleton *Singleton::pInstance_ = NULL;
Mutexlock Singleton::mutex_;


void* threadFunc(void *arg){
    Singleton *ps = Singleton::getInstance();
    cout << ps << endl;
}

int main(int argc, const char *argv[])
{
    vector<pthread_t> vec(10);
    for(vector<pthread_t>::iterator it = vec.begin(); it != vec.end(); ++it){
        pthread_create(&*it, NULL, threadFunc, NULL);
    }
    for(vector<pthread_t>::iterator it = vec.begin(); it != vec.end(); ++it){
        pthread_join(*it, NULL);
    }
    return 0;
}

2.5 总结思路

单例模式的编写：

a) 构造函数设为私有，此时无法生成对象

b) 编写一个成员函数来生成对象，但是无法调用。

c) 将该函数设为static，此时可以生成对象，但是对象不唯一。

d) 添加一个static指针成员，仅当该指针为NULL（也就是第一次访问时）才去生成对象。

e) 但是此时的代码在多线程环境下存在竞态问题。

f) 于是我们每次检查指针前都要进行加锁。

g) 此时每次获取对象都要加锁，锁争用过多，影响效率，于是我们引入“双重锁”模式（Double Check Lock Pattern， DCLP）。这种模式采用了两重判断，其中内部的判断采用了锁，保证结果的正确性，外面的检查保证大部分线程不会进入争用锁。

h) 后面我们采用pthread_once 编写单例模式。

转载于:https://www.cnblogs.com/monicalee/p/3848057.html

weixin_30414635
关注
C++单例模式(自动释放实例)
MISAYAONE的博客
09-26 1053
最基础的实现方法： #include using namespace std; class Singleton { public: static Singleton *GetInstance() { if (m_Instance == NULL ) { m_Instance = new Singleton (); } return m_Instance; }
C++ 设计模式3：单例模式
琅嬛福地
04-12 1973
单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例;具体运用场景如：设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动;数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取;
Day41、静态成员变量、静态成员函数、单例模式、成员/成员函数指针、操作符重载、友元函数
tangzihao_c的博客
09-24 566
一、            静态成员 1、 静态成员变量 class 类名{        static数据类型 数据明；//声明 }； 数据类型 类名：：变量名=初值；//定义和初始化 1） 静态成员变量不属于对象 2） 不能在构造函数中被定义和初始化，需要在类的外部单独地定义及初始化 3） 可以通过类名直接访问，也可以通过对象访问 4） 静态成员变量存放在全局区（代码段和BS
C++实现单例模式的简单例程
Ataraxia的专栏
12-04 631
在Java中使用单例模式是常用的事情 这里使用C++实现一次单例模式，虽然实际场景中很少使用这次例程有四个文件 Singleton.h Singleton.cpp Demo.cpp Client.cpp Singleton.h #ifndef _SINGLETON_H_ #define _SINGLETON_H_#include <iostream> using na
【C++】C++ 单例模式总结（5种单例实现方法）
热门推荐
unonoi的博客
11-04 9万+
C++ 单例模式的几种实现方式。
C++Primer中级，1-10
萝卜丝儿皮尔
03-02 459
# include <iostream> # include <deque> int main() { using namespace std; deque<int> a; a.push_back(3); a.push_back(4); a.push_back(5); a.push_front(2); a.push_front(0); for (size_t ncount = 0; ncount < a.size(); ++ncount) /
高效学习-笔记-左耳听风
大数据精读周刊
07-14 1079
文章目录高效学习：端正学习态度高效学习：源头、原理和知识地图信息源你要的是 “渔”，而不是 “鱼”。高效学习：深度，归纳和坚持实践举一反三写博客高效学习：如何学习和阅读代码高效学习：面对枯燥和量大的知识 高效学习：端正学习态度 如果你不能克服自己 DNA 中的弱点，不能端正自己的态度，不能坚持不能不断追问等，那么，无论有多好的方法，你都不可能学好。 在开始这一系列文章之前，我想说，如果你想从我这里得到一些速成的方法，那么你就不用往下看了，学习是不可能速成的。这里只有一些方法和技巧，是我这么多年来行之有效的
0721-----C++Primer听课笔记----------继承
weixin_30525825的博客
07-21 105
1. 通过子类对象来调用函数: 　　a)从父类继承而来的函数，可以正常使用； 　　b)子类自行添加的函数，可以正常使用； 　　c)子类编写和父类重名的函数，不管是否改变了参数，调用的都是子类的版本，如果需要调用父类的版本，需要显示指定父类名。 　　例1： #include <iostream> #include <string> using name...
0722-----C++Primer听课笔记----------虚函数和模板
weixin_30767835的博客
08-02 83
1.虚函数 　　1.1不含有任何数据成员或者虚函数的class或者struct大小为1，含有虚函数的对象在基地址部分有一个vptr，指向虚函数表，因此大小为4个字节。 　　1.2动态绑定的原理：假设派生类和基类存在覆盖的关系(基类中定义了虚函数)，那么派生类在虚函数表中，会覆盖掉基类相应的虚函数。当程序执行的时候，根据基类指针找到vptr，根据vptr找到vtable，然后找到相应的版本去...
(完整版)C++-primer-plus(第6版)中文版-编程练习答案(word版).doc
11-13
3. 函数: 函数是 C++ 中的一种编程结构，用于封装代码块，提高代码的重用性和可读性。 - 函数的定义包括函数名、参数列表和函数体。 - 函数可以返回值，也可以不返回值。 4. 输入/输出操作: C++ 提供了多种输入/...
(完整版)C-Primer-Plus第6版编程练习答案(已下载).doc
11-15
本文档总结了 C 语言程序设计的基础知识点，涵盖了变量、数据类型、运算符、控制流语句、函数和数组等方面的内容。 变量和数据类型 * 变量是存储值的命名存储单元 * C 语言支持多种数据类型，包括整数（int）、...
C++课程设计报告-计算器的设计与实现样本.doc
11-19
[1] C++ Primer, 5th Edition, Lippman, S. B. [2] VC++ 6.0 Programming, Microsoft Press. 附录1 源程序清单： 计算器的设计与实现 // Calculator.h #ifndef CALCULATOR_H #define CALCULATOR_H class ...
(完整word版)c++-primer-plus(第六版)第二至第六章课后编程练习全部答案.doc
11-15
"C++primer Plus第六版第二至第六章课后编程练习答案" 本文档提供了C++primer Plus第六版第二至第六章的课后编程练习答案，涵盖了C++语言的基础知识和编程实践。这些练习题目涵盖了基本的输入输出、变量、数据类型...
Cpp-Primer:C ++ Primer解决方案第五答案
04-01
C ++ Primer解决方案第五答案 概述 该项目仅包括C ++ Primer 5th的第8章至第19章的解决方案。 环保环境 WSL Ubuntu 20.04 编译器 gcc 9.3.0 编辑 Visual studio code 语境 第二部分：C ++库 第9章顺序容器 第10章...
C++基础_关于拷贝构造函数（复制构造函数）RVO
学海无涯
11-11 684
VS2022会直接跳过拷贝构造或移动构造，直接在目标对象内存中构造返回对象，优化性能
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 239
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 668
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
STL之vecor的使用(超详解)
最新发布
2302_80220709的博客
11-11 499
如果发生的异地扩容，这时的迭代器就不在指向原来的空间，而就指向一块释放的内存，我们一旦继续访问就会报错，这种现象我们称为迭代器失效。指定位置插入，要注意的是这里不再像string一样，用的size_t 的pos，vector虽然也可以用下标访问，但是为了承接后面STL其他不支持下标访问的容器，所以这边的pos用的是迭代器类型。下面我们开始研究他的使用，为了能够更好的测试，我们先实现一个打印容器元素的函数，vector底层是数组，所以有三种访问方式：下标访问、迭代器访问、范围for（本质也是迭代器）
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1716
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
侯捷设计模式讲稿-2007：C++实战与经典图书解析
3. "C++ Primer" by Lippman - 长期畅销的C++教程，是C++学习者的首选。 4. "Inside the C++ Object Model" by Lippman - 揭示了C++对象模型的底层细节，难度较高。 5. "Effective C++" - 通过50个编程实例展示了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值