linux C++ day06

最新推荐文章于 2023-01-06 19:47:29 发布

蒙宇

最新推荐文章于 2023-01-06 19:47:29 发布

阅读量199

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/qq_40632341/article/details/104303363

版权

C++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

本文介绍了如何在C++中实现支持结息调息功能的银行账户类，以及三种单例模式（饿汉式、懒汉式、线程安全的单例模式）的实现步骤。此外，还讲解了通过成员指针访问对象的原理和方法，包括成员变量指针、成员函数指针和静态成员指针的使用。

摘要由CSDN通过智能技术生成

目录：
支持结息调息功能的银行账户类
饿汉式的单例模式
懒汉式的单例模式
考虑线程安全的单例模式
通过成员指针访问对象
1 支持结息调息功能的银行账户类
1.1 问题
静态成员变量不包含在对象实例中，具有进程级的生命周期。静态成员函数没有this指针，也没有常属性。但是静态成员受类作用域和访问控制限定符的约束。静态成员变量的声明在类中；而定义和初始化，只能在类的外部而不能在构造函数中进行。静态成员变量为该类的所有对象实例所共享。类的静态成员变量通常用于表示需要在该类的多个实例化对象间共享的属性，如银行账户的利率。

静态成员函数只能访问静态成员变量或调用静态成员函数。非静态成员函数既可以访问静态成员变量或调用静态成员函数，也可以访问非静态成员变量或调用非静态成员函数。类的静态成员函数一方面可以独立于对象充当静态成员变量的访问接口，另一方面它也可以在不破坏封装性的前提下，让一个类有能力管理自己的对象。

访问静态成员，既可以通过类也可以通过对象。

1.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：支持结息调息功能的银行账户类

代码如下：

#include
class Account
{
private:
std::string m_name;
long m_number;
double m_principal;
static double s_interest;
public:
Account(std::string const& name, const long& number, const double& principal) : m_name(name), m_number(number), m_principal(principal)
{
}
static void setInterest(const double& interest)
{
s_interest = interest;
}
static double getInterestRate()
{
return s_interest;
}
double getInterest()
{
return m_principal * s_interest;
}
};
double Account:😒_interest = 0.001;
int main(int argc, const char * argv[])
{

std::cout << "当前利率是：" << Account::getInterestRate() << std::endl;
Account zhangsan("张三", 1234567890123, 1000);
std::cout << "存款利息是：" << zhangsan.getInterest() << std::endl;

//利率调整
Account::setInterest(0.002);
std::cout << "利率调整后的存款利息是：" << zhangsan.getInterest() << std::endl;


return 0;

}
上述代码中，以下代码：

static double s_interest;

在类Account中声明了一个私有的静态成员变量s_interest。

上述代码中，以下代码：

double Account:😒_interest = 0.001;
在类Account的外部定义并初始化了静态成员变量s_interest。

上述代码中，以下代码：

static void setInterest(const double& interest)
{
    s_interest = interest;
}
static double getInterestRate()
{
    return s_interest;
}

在类Account中定义了两个静态成员函数，第一个函数用于调息，第二个函数用于获取当前利率值。

上述代码中，以下代码：

double getInterest()
{
    return m_principal * s_interest;
}

在类Account中定义了一个普通成员函数，用于结息。

上述代码中，以下代码：

std::cout << "当前利率是：" << Account::getInterestRate() << std::endl;

显示了当前利率值是多少，值得注意的是，获取当前利率值是用Account::getInterestRate()方法获得的，这是允许的。C++规定，访问静态成员，既可以通过类也可以通过对象。

1.3 完整代码
本案例的完整代码如下所示：

std::cout << "当前利率是：" << Account::getInterestRate() << std::endl;
Account zhangsan("张三", 1234567890123, 1000);
std::cout << "存款利息是：" << zhangsan.getInterest() << std::endl;

//利率调整
Account::setInterest(0.002);
std::cout << "利率调整后的存款利息是：" << zhangsan.getInterest() << std::endl;


return 0;

}
2 饿汉式的单例模式
2.1 问题
单例模式使用私有构造函数的方法禁止在类外部创建实例，而类自己使用静态成员变量的方法来维护其唯一实例，并提供访问该实例的方法。

饿汉式单例模式的优点是加载进程时静态创建单例对象，线程安全；缺点是无论使用与否，总要创建一个实例。

2.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：饿汉式的单例模式

代码如下：

#include
class Singleton
{
private:
Singleton (void)
{
}
Singleton (Singleton const& that)
{
}
static Singleton s_instance;
public:
static Singleton& getInstance (void)
{
return s_instance;
}
};
Singleton Singleton:😒_instance;
int main(int argc, const char * argv[])
{

Singleton& a = Singleton::getInstance();
std::cout << std::hex << &a << std::endl;
Singleton& b = Singleton::getInstance();
std::cout << std::hex << &b << std::endl;

return 0;

}
上述代码中，以下代码：

private:
Singleton (void)
{
}
Singleton (Singleton const& that)
{
}
通过将类Singleton的构造函数和拷贝构造函数定义成私有的，来禁止在类外创建该类的对象。

上述代码中，以下代码：

static Singleton s_instance;

将单例类的唯一对象实例，实现为其静态成员变量。虽然静态成员变量s_instance需要在类的外部实例化，但它毕竟是Singleton类的成员(尽管是静态成员)，依然属于类的内部元素，可以调用该类的私有构造函数。

上述代码中，以下代码：

static Singleton& getInstance (void)
{
    return s_instance;
}

通过成员函数getInstance来获得类Singleton的唯一对象实例。

2.3 完整代码
本案例的完整代码如下所示：

Singleton& a = Singleton::getInstance();
std::cout << std::hex << &a << std::endl;
Singleton& b = Singleton::getInstance();
std::cout << std::hex << &b << std::endl;

return 0;

}
3 懒汉式的单例模式
3.1 问题
单例模式使用私有构造函数的方法禁止在类外部创建实例，而类自己使用静态成员变量的方法来维护其唯一实例，并提供访问该实例的方法。

饿汉式单例模式的优点是用则创建，不用不创建，什么时候用什么时候创建；缺点是首次访问时动态创建单例对象，在多线程应用中，存在线程不安全的问题。

3.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：懒汉式的单例模式

代码如下：

#include
class Singleton
{
private:
Singleton (void)
{
}
Singleton (Singleton const& that)
{
}
static Singleton* s_instance;
public:
static Singleton& getInstance (void)
{
if (! s_instance)
s_instance = new Singleton;
return s_instance;
}
};
Singleton Singleton:😒_instance = NULL;
int main(int argc, const char * argv[])
{

Singleton& a = Singleton::getInstance();
std::cout << std::hex << &a << std::endl;
Singleton& b = Singleton::getInstance();
std::cout << std::hex << &b << std::endl;

return 0;

}
上述代码中，以下代码：

private:
Singleton (void)
{
}
Singleton (Singleton const& that)
{
}
通过将类Singleton的构造函数和拷贝构造函数定义成私有的，来禁止在类外创建该类的对象。

上述代码中，以下代码：

static Singleton* s_instance;

声明了类Singleton的静态指针，该指针在类外定义时，被初始化为空，如以下代码所示：

Singleton* Singleton:😒_instance = NULL;
上述代码中，以下代码：

static Singleton& getInstance (void)
{
    if (! s_instance)
        s_instance = new Singleton;
    return *s_instance;
}

通过成员函数getInstance来获得类Singleton的唯一对象实例。与饿汉式的区别是在函数getInstance第一次被调用时，才创建唯一对象实例，而不是在创建程序一开始就创建唯一对象实例。

3.3 完整代码
本案例的完整代码如下所示：

Singleton& a = Singleton::getInstance();
std::cout << std::hex << &a << std::endl;
Singleton& b = Singleton::getInstance();
std::cout << std::hex << &b << std::endl;

return 0;

}
4 考虑线程安全的单例模式
4.1 问题
饿汉式单例模式在多线程应用中，由于是多线程并发执行，有可能创建出多个对象实例，存在线程不安全的问题。借助互斥锁能够防止单例对象在不同线程中被重复创建。

4.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：考虑线程安全的单例模式

代码如下：

#include
class Singleton
{
private:
Singleton (void)
{
}
Singleton (Singleton const& that)
{
}
static Singleton* s_instance;
static pthread_mutex_t s_mutex;
public:
static Singleton& getInstance (void)
{
if (! s_instance)
{
pthread_mutex_lock (&s_mutex);
if (! s_instance)
s_instance = new Singleton;
pthread_mutex_unlock (&s_mutex);
}
return s_instance;
}
};
Singleton Singleton:😒_instance = NULL;
pthread_mutex_t Singleton:😒_mutex = PTHREAD_MUTEX_INITIALIZER;_
int main(int argc, const char * argv[])
{

Singleton& a = Singleton::getInstance();
std::cout << std::hex << &a << std::endl;
Singleton& b = Singleton::getInstance();
std::cout << std::hex << &b << std::endl;

return 0;

}
上述代码中，以下代码：

static Singleton& getInstance (void)
{
    if (! s_instance)
    {
        pthread_mutex_lock (&s_mutex);
        if (! s_instance)
            s_instance = new Singleton;
        pthread_mutex_unlock (&s_mutex);
    }
    return *s_instance;
}

在获得类Singleton的唯一对象实例的成员函数getInstance中，通过加互斥锁的方法来保证多线程安全。如下代码：

        pthread_mutex_lock (&s_mutex);

首先设置互斥变量s_mutex，此时如果有其它线程已经设置了该变量，则当前线程就等待，直到其他线程释放互斥变量，此线程才重新开始执行。

以下代码：

        pthread_mutex_unlock (&s_mutex);

是释放互斥变量s_mutex。

4.3 完整代码
本案例的完整代码如下所示：

Singleton& a = Singleton::getInstance();
std::cout << std::hex << &a << std::endl;
Singleton& b = Singleton::getInstance();
std::cout << std::hex << &b << std::endl;

return 0;

}
5 通过成员指针访问对象
5.1 问题
成员变量指针的本质，就是特定成员变量在类对象实例中的相对地址。成员变量指针解引用，就是根据类对象实例的起始地址，结合成员变量指针中的相对地址，计算出具体成员变量的绝对地址，并访问之。类的静态成员变量不是对象的一部分，不需要根据相对地址计算绝对地址，也不需要通过对象或其指针解引用。

成员函数并不存储在对象中，不存在根据相对地址计算绝对地址的问题，但是需要通过对象或对象指针对成员函数指针解引用，其目的只有一个，即提供this指针。类的静态成员函数没有this指针，无需调用对象。

静态成员与对象无关，因此静态成员指针与普通指针并没有任何本质性区别。

5.2 步骤
实现此案例需要按照如下步骤进行。

步骤一：通过成员变量指针访问成员变量

代码如下：

#include
class Student
{
public:
std::string m_name;
std::string m_sex;
int m_age;
int m_no;
};
int main(int argc, const char * argv[])
{

int Student::*p_age = &Student::m_age;
Student student;
student.*p_age = 10;
std::cout << student.m_age << std::endl;

return 0;

}
上述代码中，以下代码：

int Student::*p_age = &Student::m_age;

定义了一个成员变量指针p_age，指向类Student的变量成员m_age.

上述代码中，以下代码：

Student student;
student.*p_age = 10;

定义了一个类Student的对象student，然后通过成员变量指针p_age，将对象student中的变量成员m_age赋值为10，这被称为解引用。其实，成员变量指针p_age指向的是变量成员m_age在对象student中的相对地址。“.*”是一个独立的运算符，成员指针解引用运算符。

步骤二：通过成员函数指针访问成员函数

代码如下：

#include
class Student
{
public:
std::string m_name;
std::string m_sex;
int m_age;
int m_no;

void who (void) const
{
    std::cout <<  "我是" << m_name << "，性别" << m_sex << "，今年" << m_age << "岁，学号" << m_no << std::endl;
}

};
int main(int argc, const char * argv[])
{

int Student::*p_age = &Student::m_age;
Student student;
student.*p_age = 10;
std::cout << student.m_age << std::endl;

student.m_name = "张三";
student.m_no = 12;
student.m_sex = "男";
void (Student::*p_who) (void) const = &Student::who;
(student.*p_who)();
return 0;

}
上述代码中，以下代码：

void (Student::*p_who) (void) const = &Student::who;

定义了一个成员函数指针p_who，指向类Student的函数成员who。

上述代码中，以下代码：

(student.*p_who)();

通过成员函数指针p_who，调用类Student的成员函数who，这被称为解引用。添加student的目的只有一个，即提供this指针。

步骤三：通过静态成员指针访问静态成员

代码如下：

#include
class Student
{
public:
std::string m_name;
std::string m_sex;
int m_age;
int m_no;

static int s_count;

void who (void) const
{
    std::cout <<  "我是" << m_name << "，性别" << m_sex << "，今年" << m_age << "岁，学号" << m_no << std::endl;
}

static void inc (void)
{
    s_count++;
}

};
int Student:😒_count = 0;
int main(int argc, const char * argv[])
{

int Student::*p_age = &Student::m_age;
Student student;
student.*p_age = 10;
std::cout << "age = " << student.m_age << std::endl;

student.m_name = "张三";
student.m_no = 12;
student.m_sex = "男";
void (Student::*p_who) (void) const = &Student::who;
(student.*p_who)();

int* p_count = &Student::s_count;
*p_count = 10;
std::cout << "count = " << Student::s_count << std::endl;

void (*p_inc)(void) = Student::inc;
(*p_inc)();
std::cout << "count = " << Student::s_count << std::endl;

return 0;

}
上述代码中，以下代码：

int* p_count = &Student::s_count;
*p_count = 10;

定义了一个静态成员指针变量p_count，指向类Student的静态变量成员s_count。静态成员指针与普通指针并没有任何本质性区别，只是成员指针受访问控制属性约束。

上述代码中，以下代码：

void (*p_inc)(void) = Student::inc;

定义了一个静态成员函数指针p_inc，指向类Student的函数成员inc。

上述代码中，以下代码：

(*p_inc)();

通过静态成员函数指针p_inc，调用类Student的成员函数inc。类的静态成员函数没有this指针，无需调用对象。

5.3 完整代码
本案例的完整代码如下所示：

#include
class Student
{
public:
std::string m_name;
std::string m_sex;
int m_age;
int m_no;

static int s_count;

void who (void) const
{
    std::cout <<  "我是" << m_name << "，性别" << m_sex << "，今年" << m_age << "岁，学号" << m_no << std::endl;
}

static void inc (void)
{
    s_count++;
}

};
int Student:😒_count = 0;
int main(int argc, const char * argv[])
{

int Student::*p_age = &Student::m_age;
Student student;
student.*p_age = 10;
std::cout << "age = " << student.m_age << std::endl;

student.m_name = "张三";
student.m_no = 12;
student.m_sex = "男";
void (Student::*p_who) (void) const = &Student::who;
(student.*p_who)();

int* p_count = &Student::s_count;
*p_count = 10;
std::cout << "count = " << Student::s_count << std::endl;

void (*p_inc)(void) = Student::inc;
(*p_inc)();
std::cout << "count = " << Student::s_count << std::endl;

return 0;

}