c++类和类的封装，对象线程封装
1. C++面向对象编程介绍
面向对象编程(Object Oriented Programming)，简称OOP。
在传统的面向过程编程中，数据以及数据的相关操作函数都是分离的独立个体；
对象，如周围的一切其实都是对象；就编程角度，对象包括A)一系列属性（数据）；B)一系列操作（函数）。
OOP提供了设计对象的功能，对象包括特性和行为，两者都囊括在一起，共同构成对象实体（即类实体）；
对象实体，使程序更模块化，更易读易写，提升了代码重用到一个更高的层次；
对象提供了对数据操作的直接方法，定义了如何与对象进行交互，以及对象之间的交互；
更重要的是，OOP提供了更实用的概念：封装、继承、多态和抽象。
这篇主要讲述封装，即对象将数据及其操作函数封装到一个类实体中。
2. 类和类成员
C++提供了如char、int、long、float、double等基本数据类型，足够用来解决大多数哦相对简单的问题，但对于复杂的问题就比较困难了。
C++的一个实用特性是自定义数据类型；如之前的枚举和结构体：
枚举和结构体代表了传统的面向过程编程，它们只包含数据，如果需要访问此类型变量，必须提供自定义函数，并以该类型变量为参数：
在OOP世界中，我们希望自己的类型不仅包括数据，也包括操作数据的函数；C++中，通过class关键字来声明一个类。
2）类类似结构体，但它更多功能和更灵活：
类似结构体，类的声明没有分配内存，只是说明了类的结构；类的声明以分号结尾；
为了使用类，可以声明一个该类型的变量：
声明一个类的变量，也叫实例化一个类；该变量称作为类的一个实例，或者对象。
3）成员函数：
类不仅仅包含数据（成员变量），亦可以包含函数，称作成员函数：
成员函数可以类似访问成员变量，使用'.'来使用：
通常，类的成员变量，加一个前缀'm_'来区分：
3. 公有和私有
1）访问标识符：公有-public关键字，私有-private关键字
在上面的DateStruct的结构体，它的成员可以在main函数中访问，因为结构体的所有成员默认是公有的，即public;
公有成员在结构体和类中，程序的任何函数都可以访问；
但如果Date的成员没有public标识符，则会出现错误：
这个说明，类成员的默认是私有的，即private的；
私有的成员只能在类的定义之内的函数可以访问；
可以通过public关键字使成员变为公有的，即可访问了：
类和结构体的本质区别之一是类的成员可以使用标识符来控制它们的可访问性；
C++提供了3种不同的访问标识符：public、private、protect，分别是公有的、私有的和保护的：
4. 访问函数和封装
1）访问函数，也叫做读写函数；是读取和写入私有成员变量的值。
例如：
GetLength函数就是个访问函数。
访问函数有2种，即getter和setter:
将数据成员私有化，提供Getter和Setter来访问，即所谓的"封装" ；
2）封装
封装的思想就是将实现的细节隐藏，而暴露公有接口；
C++中的访问标识符，可以实现在类中的封装；通常是将所有的成员变量私有化；
尽管看起来访问成员变量的不直接，但使程序更有可重用性和可维护性；
A)封装实现，无论类的实现如何改变，只要对外的接口不发生变化即可。
如图上例，如果m_Value被重命名了，那么main函数中访问就会出错；
如果提供了m_Value的访问函数：
B)隐藏了类的实现，类的使用者只需知道公共的接口，就可以使用该类；
C)封装帮助防止意外的改变和误用；
D)对程序调试有很大的帮助，因为改变类的成员变量只用通过公共接口。
5. 构造函数Ⅰ
1)构造函数：是类的一种特殊的成员函数，当类被实例化时执行；通常用以初始化成员变量。
构造函数有明确的命名规则：A)函数名必须和类名一样；B)无返回类型（包括void)。
无参构造函数-不带参数的构造函数，是类的默认构造函数：
通常，类都包含一个默认的构造函数，可以初始化成员变量。
含参构造函数-含有参数的构造函数，可以对成员变量赋予指定的值；
以上的两个构造函数，类似重载函数；构造函数必须有唯一的前面（参数个数和参数类型）。
类亦可以只提供含参构造函数，没有默认构造函数：
6. 析构函数
析构函数是类的另一种特殊的函数，当类的对象销毁时调用；它和构造函数是成对出现的。
普通的简单类，一般不需要析构函数；因为C++会自动回收垃圾；
如果类中执行了某些动态内存分配，则需要显式定义析构函数，并释放回收垃圾；
析构函数的明确命名规则：A)函数名和类名一样，并前缀'~'；B)不能带参数（即意味着只有一个析构函数）；C)没有返回类型。
注意动态分配，必须提供析构函数，来回收分配的空间。
2）构造函数和析构函数的时序：
如上图所示，输出的依次是：simple的构造函数，pSimple的构造函数，最后是pSimple的析构函数。
构造函数和析构函数的时序是：Constructor First, Destructor Last。
7. 隐藏的'this'指针
如之前的例子中的this，是每个类的成员函数中隐藏的指针，它指向了类成员函数打交道的类的对象。
实用性：
1）当构造函数或成员函数中的参数名和成员变量名相同时，可以使用this来访问本类的成员变量；
2）可以使用this返回类的对象引用：
8. 构造函数Ⅱ
1)私有构造函数-如果不想类以外使用指定的构造函数，我们可以将它私有化。
类只能被实例化一次，称作为单一性；通常使用私有/保护构造函数进行的。
2）构造函数链和初始化
有时，一个构造函数所做的工作和另外的构造函数一样，只是增加了一些；
这样这个构造函数可以调用另外的构造函数，称作为构造函数链。如C#就支持这种格式，但C++不支持。
但构造函数可以调用类中的非构造函数，只是要注意这些非构造函数调用的成员，必须已经初始化。
通常的做法就是，定义一个公共的非构造函数，构造函数都调用它来初始化共同的；例如：
9. 类代码和头文件
1)在类的定义之外定义成员函数。
如之前的类定义，都是在类的定义中定义成员函数：
当类的定义越来越长和越来越复杂时，就显得臃肿，难以维护和操作；
幸运的是，C++提供了一种分离类的定义及其应用定义的方法，将类的成员函数在类的外面定义；格式是：类名::函数名
2)将类的定义放在头文件中：
头文件的使用可达到重用的效果；所以将类的定义放在头文件中，而成员函数放在.cpp中定义；而cpp的名字需和类的名字相同。
Date.h:
Date.cpp:
推荐分离类的定义中的成员函数到类外定义。
10. 常量类对象和成员函数
函数的参数可以为常量对象，如内置的基本数据类型一样，类对象也可以声明为常量，所有常量对象的变量必须在创建时初始化，其后不能修改。
上图3个错误，因为程序试图修改常量类对象的变量；
因为常量类对象不能调用非常量成员函数；
常量成员函数-保证不修改任何类变量或调用任何非常量函数。
为了使GetValue常量化，可以在其原型加个const关键字：
注意：
A) 常量成员函数在类外定义时，也必须加const关键字；
B) 任何常量成员函数试图修改类成员变量，或者调用非常量成员函数都是非法的，会产生编译错误。
C)构造函数不能常量化；
重载函数使用const和非const，是当返回类型不一样的时候。
11. 静态成员变量
在之前的程序中，静态表示变量的值在运行期间保持最新的值；
1）静态成员变量
在实例化两个对象，其包含的相同的成员变量；
静态成员变量是属于类的本身，是所有对象的共享变量；它的值是保持修改的最新值；
使用格式：类名::静态成员。
2）静态成员变量的初始化
初始化必须在类的代码文件中进行。
12. 静态成员函数
如静态成员变量一样，静态成员函数是属于类的本身，不属于任何类的对象；
如静态成员变量访问一样，可以通过：类名::静态成员来访问类的静态成员变量。
注意：静态成员函数，没有this指针；
例如：
13. 友元类和友元函数
多数时候，类和函数需要运行很紧密；但需使用显示函数来打印相关信息，这并不显得很隐藏类的细节；
这时，友元类很友元函数就很好的访问私有细节；
1）友元函数
友元函数访问类的私有成员，就如其是类的一个成员函数。
一个友元函数可以是，也可以不是其他类的成员函数；使用关键字friend。
例如：
一个友元函数可以是多个类的友元函数；
2)友元类
友元类是，声明在其他类中，可以访问其他类的私有变量；
在使用友元函数和友元类时，请务必谨慎。
14. 匿名变量和对象
所谓匿名，就是可以不通过命名变量来访问，减少临时变量。
【免责特此声明：
1）本内容可能是来自互联网的，或经过本人整理的，仅仅代表了互联网和个人的意见和看法！
2）本内容仅仅提供参考，任何参考该内容造成任何的后果，均与原创作者和本博客作者无关！】
C++学习:类,对象,封装
- 类
- 对象
-
封装
C++是一门集面向过程,面向对象以及泛型编程于一体的强大的编程语言,在这里面最重要的要属面向对象了吧???什么是面向对象?面向对象的思想是什么???总结下来就一句话:万物皆对象.在面向对象的世界里,一切都是可以用对象来解释的.这也是面向对象思想的精髓部分.
万物皆对象
1:类
举个例子:在超时里面进行商品购物的时候,它所有的商品都是按类目来划分的.生活用品,食品等.这就是按类别来分.而在自然界中也是.如:动物昆虫等.这就是类.将一类相似的的东西抽象成一类东西.
结构化程序设计
程序 = 算法 +数据结构
面向对象设计OOP
OBJECT ORIENRED PROGRAMING
Object oritened programing
程序 = 对象 +对象 +....
关键:让每个对象都负责执行一组相关的任务
面向对象开发范式的特性：
万物皆是对象
程序是一组对象彼此之间在发送消息
每个对象都有自己的内存占用，可以组装成更大的对象
每个对象都有类型,特定类型的对象都可以接收相同的消息
概念：
类：类是创建对象的模板和蓝图，类是一组相似对象的共同抽象定义
对象：对象是类的实例化结果，对象是实实在在的存在，代表现实世界的某一事物
对象的三大特性：
行为：对象能干什么
状态：对象的属性，行为的结果
标识：对象的唯一身份；
类和对象的区别：
类是静态定义
对象是动态实例
建立模型得到的是类而非对象
联系：
类是对象的定义
对象的产生离不开类这个模板
类存在的摸底是实例化得到对象
世界是由对象组成的
定义一个类的步骤:
1:定义类名
2:编写类的数据成员代表属性
3:编写类的方法代表行为
类的建模是一个抽象和封装的过程：
抽象：去掉不关注的，次要的信息而保留重要的信息
封装：信息打包
具体一点：将数据和行为结合在一个包中，对对象的使用者隐藏数据的具体实现方式
实现封装的关键：不能让类中的方法直接访问其他类的内部数据，只能通过公开行为方法间接访问：
例子:
class ClassName{
field1;
field2;
.....;
constructor;
.....
method1;
method2;
}
对象的两种类的形式：
1:结构体形式：
struct Saving{
unsigned accountNumber;
float balance;
};
缺点:安全性不好,任何人都是可以进行访问的
2:class形式：
class Savings{
public:
float deposit(float amount){
balance +=amount;
return balance;
}
private:
unsigned accountNumber;
float balance;
};
优点:类不仅可以保护数据,而且可以提供成员函数来操作
C++用类来定义抽象数据类型
C++早期的版本被成为带类的C
class 类名称{
public:
//共有函数
protected：
//保护成员
private:
//私有函数
//私有成员
int val;
};
类中定义成员函数：
class Tdate{
public:
void set(int m = 1,int d = 2,int y = 3){
month = m;
day = d;
year = y;
}
bool isLeepYear(){
return (year%4 ==0 &&year%100!=0) || (year %400==0);
}
void print(){
cout< 在类中定义成员函数：
类中定义的成员函数一般都为内联函数，即使没有明确用inline标示
在C++中，类定义通常在头文件中，因此这些成员函数定义也伴随这进入头文件
在类之后定义成员函数：
C++允许在其他地方定义成员函数；
将类定义和其成员函数定义分开，是目前开发程序的通常做法
我们把类定义看成是类的外部接口，类的成员函数定义看成是类的内部实现
看一个最简单的实例:在main.cpp中去定义一个类.并且在此类中直接实现成员函数.(也可以通过Car.h和Car.cpp的形式去实现)
- 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
- 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
通过Car.cpp及Car.h来实现一个简单类的封装
- 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
- 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
- 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
- 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
以上是简单的关于类和对象以及一个简单的封装的国政
在成员函数中访问成员：
成员函数必须用对象来调用
Car mCar;
mCar.run();
在成员函数内部，访问数据成员或成员函数无需如此
void setProperty(int price,int carNum){
this->mPrice = price;
this->mCarNum = carNum;
}
this指针代表当前对象占用内存空间的地址:
void Tdate::set(int m ,int d,int y){
this->month = m;
this->day = d;
this->year = y;
}
通过指针来调用成员函数：
例子:
#include"tdate.h"
#include
void func(Tdate *pDate){
pDate->print();
if(pDate->isLeepYear()){
cout<<"leepyear"< 通过引用来调用成员函数:
#include"tdate.h"
#include
void func(Tdate &pDate){
pDate.print();
if(pDate.isLeepYear()){
cout<<"leepyear"< 类的成员函数的重载：
类的成员函数可以像普通函数一样进行重载
但是不同的类即使有相同的函数名也不算重载
类的成员函数可以默认设置成员参数：
在类之外去定义这样一个类的行为
OOP三大特性(面向对象的三个特性)：
继承(inheritance)：
多态(polymorphism):
封装(encapsulation)：类背后隐藏的思想是数据抽象和封装
信息隐藏，隐藏对象的实现细节，不让外部直接访问
将数据成员和成员函数一起包装到 一个单元中 ，单元以类的形式实现
将数据成员和成员函数包装进类中，加上具体实现的隐藏，共同被称作封装，其结果是一个同时带有特征和行为的数据类型
封装类:定义类，定义其成员函数的过程称为封装类
细节:
除非必须公开底层的实现细节,否则应该将所有字段指定为private
使数据成员私有,控制数据访问限制.增强了类的可维护性
隐藏方法的具体实现.向外部提供公开的接口.以供安全调用
信息隐藏是OOP最重要的特性之一,也是可以使用访问修饰符的原因
访问修饰符号：
public
protected
private
信息隐藏的原因:
对模块的任何实现细节所做的更改不会影响使用该模块的代码
防止用户意外的修改数据
使模块易于使用和维护
class 类名
{
定义一个点(Point)类, 具有以下属性和方法:
■ 属性: x坐标, y坐标
■ 方法: 1.设置x,y的坐标值; 2.输出坐标的信息。
实现代码:
上段代码中定义了一个名为 Point 的类, 具有两个私密属性, int型的xPos和yPos, 分别用来表示x点和y点。
1 数据抽象和封装
封装是将相关的概念组成一个单元，然后通过一个名称来引用它。面向对象封装是将数据和基于数据的操作封装成一个整体对象，对数据的访问或修改只能通过对象对外提供的接口进行。
没有成员的类是空类，空类也占用空间。
sizeof(People) = 1;
（2）在类内部声明，加上inline关键字，在类外部定义。
（3）在类内部声明，在类外部定义，同时加上inline关键字。注意：此种情况下，内联函数的定义通常应该放在类定义的同一头文件中，而不是在源文件中。这是为了保证内联函数的定义在调用该函数的每个源文件中是可见的。
静态常量整型（包括char,bool）数据成员可以直接在类的定义体中进行初始化，例如：
class Screen;
void Test1(Screen& a){};
在创建类的对象之前，必须完整的定义该类，而不只是声明类。所以，类不能具有自身类型的数据成员，但可以包含指向本类的指针或引用。
class LinkScreen
{
Screen window;
LinkScreen* next;
LinkScreen* prev;
}; //注意，分号不能丢
class LinkScreen{ /* ... */ };
public:
Screen& set(char);
};
contents[cursor] = c;
return *this;
}
7 类作用域
{
index row = r * width; // compute the row location
return contents[row + c]; // offset by c to fetch specified character
}
注意：成员函数的返回类型不一定在类作用域中。可通过 类名::来判断是否是类的作用域，::之前不属于类的作用域，::之后属于类的作用域。例如
构造函数名字与类名相同，不能指定返回类型（也不能定义返回类型为void），可以有0-n个形参。
在创建类的对象时，编译器就运行一个构造函数。
Sales_item item1("0-201-54848-8");
Sales_item *p = new Sales_item();
第一种情况下，运行接受一个 string 实参的构造函数，来初始化变量item1。
与其他函数一样，构造函数具有名字、形参表和函数体。
初始化列表比构造函数体先执行。不管成员是否在构造函数初始化列表中显式初始化，类类型的数据成员总是在初始化阶段初始化。
没有默认构造函数的类类型的成员，以及 const 或引用类型的成员，必须在初始化列表中完成初始化。
每个成员在构造函数初始化列表中只能指定一次。重复初始化，编译器一般会有提示。
成员被初始化的次序就是定义成员的次序，跟初始化列表中的顺序无关。
3.3 初始化式表达式
Sales_item(const std::string &book, int cnt, double price): isbn(book), units_sold(cnt), revenue(cnt * price) { }
3.4 类类型的数据成员的初始化式
初始化类类型的成员时，要指定实参并传递给成员类型的一个构造函数，可以使用该类型的任意构造函数。
Sales_item(): isbn(10, '9'), units_sold(0), revenue(0.0) {}
在类A的构造函数初始化列表中没有显式提及的每个成员，使用与初始化变量相同的规则来进行初始化。
class A
{
public:
int ia;
B b;
};
A类对象A a;不管a在局部作用域还是全局作用域，b使用B类的默认构造函数来初始化，ia的初始化取决于a的作用域，a在局部作用域，ia不被初始化，a在全局作用域，ia初始化0。
为所有形参提供默认实参的构造函数也定义了默认构造函数。例如：
{
public:
char c1;
};
5.1 只含单个形参的构造函数能够实现从形参类型到该类类型的一个隐式转换
通过将构造函数声明为 explicit，来防止在需要隐式转换的上下文中使用构造函数：
1.1 几个要点
(3) 复制控制
对于内置类型，例如int, double等，直接初始化和复制初始化没有区别。
对于类类型：直接初始化直接调用与实参匹配的构造函数；复制初始化先使用指定构造函数创建一个临时对象，然后用复制构造函数将那个临时对象复制到正在创建的对象。直接初始化比复制初始化更快。
(5)形参和返回值
vector
编译器首先使用 string 默认构造函数创建一个临时值，然后使用复制构造函数将临时值复制到 svec 的每个元素。
(7)构造函数与数组元素
如果使用常规的花括号括住的数组初始化列表来提供显式元素初始化式，则使用复制初始化来初始化每个元素。根据指定值创建适当类型的元素，然后用复制构造函数将该值复制到相应元素：
Sales_item primer_eds[] = { string("0-201-16487-6"),
string("0-201-54848-8"),
string("0-201-82470-1"),
Sales_item()
};
如果没有定义复制构造函数，编译器就会为我们合成一个。
合成复制构造函数的行为是，执行逐个成员初始化，将新对象初始化为原对象的副本。
逐个成员初始化：合成复制构造函数直接复制内置类型成员的值，类类型成员使用该类的复制构造函数进行复制。
例外：如果一个类具有数组成员，则合成复制构造函数将复制数组。复制数组时合成复制构造函数将复制数组的每一个元素。
最好显式或隐式定义默认构造函数和复制构造函数。如果定义了复制构造函数，必须定义默认构造函数。
有些类需要完全禁止复制。例如，iostream 类就不允许复制。延伸：容器内元素不能为iostream
为了防止复制，类必须显式声明其复制构造函数为 private。
与复制构造函数一样，如果类没有定义自己的赋值操作符，则编译器会合成一个。
(2)合成赋值操作符
一般而言，如果类需要复制构造函数，它也会需要赋值操作符。
构造函数的用途之一是自动获取资源；与之相对的是，析构函数的用途之一是回收资源。除此之外，析构函数可以执行任意类设计者希望在该类对象的使用完毕之后执行的操作。
(1) 何时调用析构函数
- 撤销（销毁）类对象时会自动调用析构函数。
- 变量（类对象）在超出作用域时应该自动撤销（销毁）。
- 动态分配的对象(new A)只有在指向该对象的指针被删除时才撤销（销毁）。
- 撤销（销毁）一个容器（不管是标准库容器还是内置数组）时，也会运行容器中的类类型元素的析构函数（容器中的元素总是从后往前撤销）。
如果类需要定义析构函数，则它也需要定义赋值操作符和复制构造函数，这个规则常称为三法则：如果类需要析构函数，则需要所有这三个复制控制成员。
(3)合成析构函数
友元不是授予友元关系的那个类的成员，所以它们不受声明出现部分的访问控制影响。
static 成员遵循正常的公有／私有访问规则。
(1) static 成员的名字是在类的作用域中，因此可以避免与其他类的成员或全局对象名字冲突。
(2) 可以实施封装。static 成员可以是私有成员，而全局对象不可以。
(3) 通过阅读程序容易看出 static 成员是与特定类关联的,这种可见性可清晰地显示程序员的意图。
在类的内部声明函数时需要添加static关键字，但是在类外部定义函数时就不需要了。
因为static 成员是类的组成部分但不是任何对象的组成部分，所以有以下几个特点：
1) static 函数没有 this 指针
2) static 成员函数不能被声明为 const （将成员函数声明为 const 就是承诺不会修改该函数所属的对象）
static 数据成员可以声明为任意类型，可以是常量、引用、数组、类类型，等等。
static 数据成员必须在类定义体的外部定义（正好一次）,并且应该在定义时进行初始化。
double Account::interestRate = 0.035;
静态常量整型数据成员可以直接在类的定义体中进行初始化，例如：
static const int period = 30;
（1）static 数据成员的类型可以是该成员所属的类类型。非 static 成员只能是自身类对象的指针或引用
class Screen
public:
// ...
private:
static Screen src1; // ok
（2）非 static 数据成员不能用作默认实参，static 数据成员可用作默认实参
public:
Screen& clear(char = bkground);
private:
static const char bkground = '#';//static const整形变量可以在类内部初始化。
};
这段时间看了不少C＋＋代码，也写了一个小项目，这篇文章来说一下我见到过的比较通用的两种多线程封装方式，实现平台为Linux
首先说说地一种线程封装方式，也是我们平常见得最多的一种封装方式，是用面向对象中的继承，多态来实现的，下面来看具体的代码，这些代码使我随手写的，主要是为了说明思想，如果要用到项目中还需要完善。
- /*************************************************************************
- > File Name: Thread.cpp
- > Author: KevinFu
- > Mail: [email protected]
- > Created Time: 2014年05月26日 星期一 21时27分51秒
- ************************************************************************/
- #include
- #include
- using namespace std;
- class Thread
- {
- public:
- Thread(string name = "Unknown")
- {
- }
- virtual ~Thread()
- {
- }
- void Start()
- {
- pthread_create(&m_ThreadID, NULL, ThreadFunc, this);
- }
- static void* ThreadFunc(void* pth)
- {
- Thread* p = static_cast
- p->Run();
- }
- virtual void Run() = 0;
- private:
- pthread_t m_ThreadID;
- };
- class Test:public Thread
- {
- public:
- virtual void Run()
- {
- while(1)
- {
- cout<<"In Test::Run()"<
- }
- }
- };
- int main()
- {
- Thread* thread1 = new Test();
- thread1->Start();
- sleep(1);
- }
这里我们用Thread这个类来实现线程的封装，用户自己要启用的线程类都要继承这个Thread类，在Thread类的Start函数里，调用了pthread_create创建了一个线程，并将ThreadFunc设置为线程函数，把线程的this指针传递给了这个函数，在这个线程函数里调用了
虚函数Run，这个Run函数最终会利用多态调用到用户线程类的Run函数，这就是上面代码的基本原理，比较简单，这也是面向对象用的比较多的地方，也可以说是他的强大的地方，不过用起来比较别扭，我们公司的关于线程的封装就是用的这种方法，个人感觉很麻烦，不好用，用户要想启用一个线程，必须要继承Thread这个类，而且要覆盖Run这个虚函数，很麻烦。
下面这种线程封装方式是用基于对象的封装方式，上面的封装方式是面向对象的，这种方式我们用到了boost库中的神器boost::function, boost::bind，这个神器原理就是帮定一个函数对象，函数对象可以包含参数，我们可以利用这个神器调用任意全局函数，甚至类的成员函数，
而不需要继承自任何类，下面来看具体代码
- /*************************************************************************
- > File Name: Thread.cpp
- > Author: KevinFu
- > Mail: [email protected]
- > Created Time: 2014年05月26日 星期一 20时41分07秒
- ************************************************************************/
- #include
- #include
- #include
- #include
- using namespace std;
- class Thread
- {
- typedef boost::function<void(void)> ThreadFunctionCallBack;
- public:
- Thread(ThreadFunctionCallBack cb, string name = "Unknow")
- :m_cb(cb)
- {
- }
- ~Thread()
- {
- }
- void Start(void)
- {
- pthread_create(&m_ThreadID, NULL, ThreadFunction, this);
- }
- static void* ThreadFunction(void* obj)
- {
- Thread* thread = static_cast
- thread->m_cb();
- }
- private:
- ThreadFunctionCallBack m_cb;
- pthread_t m_ThreadID;
- };
- class Test
- {
- public:
- void run(void)
- {
- cout<<"In test::run()"<
- }
- };
- int main()
- {
- Test t;
- Thread thread1(boost::bind(&Test::run, &t));
- thread1.Start();
- usleep(100);
- }
我们可以看到Test类不需要继承自Thread类，我们直接可以将boost::bind帮定的函数对象传递给Thread的构造函数，这里为了简单我们把this指针传递给了ThreadFunc，我们完全可以传递任何参数给ThreadFunc， 因为我们不需要使用多态，这就是基于对象的思想，比面向对象似乎更直接，使用起来更方便，更简单。
C＋＋11中的tr1中已经包含了boost这两大功能，boost确实是代表着最高水平的C＋＋库，其中有很多东西值得学习，也有很多东西即将加入到标准C＋＋库中。