当前位置：首页 > news >正文

C++面向对象高级开发A

news 来源：原创 2024/9/19 8:55:46

一、概述

目标：培养正规、大气的编程习惯；学习面向对象设计
- Object Based（基于对象）：以良好的方式编写C++class
  - class without pointer members【示例：Complex类】
  - class with pointer members【示例：String类】
- Object Oriented（面向对象）：学习Classes之间的关系
  - 继承（inheritance）
  - 复合（composition）
  - 委托（delegation）
推荐书籍

《C++11 Primer》

《The C++ Programming Language》

《Effective C++》

《Effective C++ Third Edition》

二、Object Based（基于对象）：以良好的方式编写C++class

1.Complex类：class without pointer members

总结：设计一个好的类需要注意：

构造函数尽量使用初始化列
成员函数尽量使用常函数
函数参数的传递尽量使用【引用】，尽量使用【const】修饰
函数返回值在可以的情况下，尽量使用【引用】
成员变量尽量放到private中，函数绝大部分放到public中

#ifndef __COMPLEX__//1.Header（头文件）中的防卫声明
#define __COMPLEX__#include<iostream>using namespace std;//<<<<<<<<<<<<<<<<<<<<<<<<布局1：前置声明（forward declarations）<<<<<<<<<<<<<<<<<<<<<<<<//<<<<<<<<<<<<<<<<<<<<<<<<布局2：类-声明（class declarations）<<<<<<<<<<<<<<<<<<<<<<<
class complex
{
/*** 2.函数（构造函数或成员函数）* 	a. 若在class body内定义完成，便自动成为【inline】候选人* 	b. 成员函数都有隐藏的this指针*/
public://3.访问级别/*** 4.构造函数：* 	a. 考虑添加使用默认实参* 	b. 尽量使用初始化列（initialization list），而不使用赋值（assignments）*		注意：赋值会比初始化效率差一些* 	c. 构造函数可以重载* 		注意：complex():re(0),im(0){} 这个构造函数和下边的构造函数重载冲突* 	d. 特殊使用：把构造函数放到private中，单例模式*  */complex(double r=0, double i=0) : re(r), im(i)//初始化列表{}/*** 5.const member function（常函数）： 在函数后边加const* 	常对象只能调用常函数：* 		注意：不改变数据内容的都“必须”加上const* 		如果没有加，在用户将complex设置为常对象（说明对象不能改变数据）时，* 		但是没有将用户调用的函数设置为常函数（说明这个函数可以改变），* 		这是矛盾的，编译器会报错！！！* * 6.参数传递：（pass by value vs. pass by reference - to const）* 	a.使用优先级：引用>指针>值（尽量使用引用，引用比指针更大气），可以提高效率*	b.尽量加const：不改变参数* * 7. 返回值传递：（return by value vs. return by reference - to const）* 	尽量使用引用：传递者无需知道接收者是以reference形式接收* 		例如_doapl函数：这里返回的是object（传递者），但是返回值类型是引用（接收者）* 		*/double real() const {return re;}//定义double imag() const {return im;}/*** 9. 操作符重载+=（成员函数、二元操作符）* 		会将this隐藏掉【complex& operator+=(this,const complex&);】* 		c3+=（c2=+c1）：连串使用操作符时，需要考虑返回值是【引用】		*/complex& operator+=(/*this,*/const complex&);//声明private:double re, im;/*** 8. 友元函数：可以自由取得private成员* 	注意：相同类的对象可以互相访问私有成员【相同类的各个对象互为友元】*/friend complex& _doapl(complex*, const complex&);
};//<<<<<<<<<<<<<<<<<<<<<<<<布局3：类-定义（class definition）<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<inline complex& 
_doapl(complex* ths, const complex& r)
{ths->re += r.re;ths->im += r.im;return *ths;
}//<<<<<<<<<<<<<<<<<<<<<<<<布局4：全局函数<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
inline double 
imag(const complex& x)
{return x.imag();
}inline double 
real(const complex& x)
{return x.real();
}/*** 9. 操作符重载+（二元操作符，非成员函数【无this】）* 	注意：这个重载的返回值绝不能是reference，因为返回的必定是local object；* 		尽量将这个重载声明为非成员函数：因为成员函数重载，可能会限制参数传递* * 10. temp object（临时对象）--> typename();* 	示例：complex(real(x) + real(y), imag(x)+imag(y));*/inline complex
operator+ (const complex& x, const complex& y)
{return complex(real(x) + real(y), imag(x)+imag(y));
}inline complex
operator+ (const complex& x, double& y)
{return complex(real(x) + y, imag(x)+y);
}inline complex
operator+ (double& x, const complex& y)
{return complex(x + real(y), x+imag(y));
}/*** 9.重载运算符+和-（正负、一元运算符、非成员函数）* 	注意：+重载的返回值不能使用reference，因为返回值绑定的是const类型* 		 -重载的返回值不能使用reference，因为返回值必定是local object* */
inline complex
operator+(const complex& x)
{return x;
}inline complex
operator-(const complex& x)
{return complex(-real(x), -imag(x));
}/*** cout << c1 << c2;* 9.重载运算符<<（二元运算符只会把结果作用的运算符左侧变量）* 	注意：【只能是非成员函数】：因为这里的os对象不认识complex，无法使用this指针识别os对象；* 		参数：os对象前不能使用const修饰：因为os对象会被修改；* 		返回值：不能返回void：因为可能会连串使用操作符<<* */inline ostream&
operator<< (ostream& os, const complex& x)
{return os << '(' << real(x) << ',' << imag(x) << ')';
}#endif

2.String类：class with pointer members

//String.h#ifndef __MY_STRING_H__
#define __MY_STRING_H__#include <string.h>
#include <iostream>using namespace std;class String
{
public:String(const char* cstr = 0);String(const String& str);//copy ctor-----》String s2(s1)    String s2 = s1String& operator=(const String& str);//copy op= --------》 s2 = s1 ~String();char* get_c_str() const{return m_data;}private:char* m_data;
};inline 
String::String(const char* cstr)
{if(cstr){cout << "String::String(const char* cstr = 0)1" << endl;m_data = new char[strlen(cstr) + 1];strcpy(m_data,cstr);}else{//注意1：未指定初值：默认构造函数cout << "String::String(const char* cstr = 0)2" << endl;m_data = new char[1];*m_data = '\0';}
}inline
String::String(const String& str)
{cout << "拷贝构造函数" << endl;m_data = new char[strlen(str.m_data) + 1];strcpy(this->m_data,str.m_data);
}inline
String& String::operator=(const String& str)
{cout << "拷贝赋值函数" << endl;if(this == &str)//注意2：自我检测赋值（自己赋值自己）：如果没有这一步，下边的delete会把自身先杀掉return *this;delete[] m_data;//注意3：需要先把之前的指向的内存释放掉m_data = new char[strlen(str.m_data) + 1];strcpy(this->m_data,str.m_data);return *this;
}inline ostream&
operator<<(ostream& os, const String& str)
{return os << str.get_c_str();
}inline
String::~String()
{delete[] m_data;
}#endif // !__MY_STRING_H__

3.补充：static–静态成员变量&静态成员函数

class Account
{
public:
// 1.static的作用：将成员变量和成员函数在类中独立出去；static double m_rate;static void set_rate(const double& x){m_rate = x;}
};
// 2.静态Data必须在类外定义（这里是在分配内存，上边只是声明），可以不用赋初值；
double Account::m_rate = 8.0;int main()
{
// 3.两种调用方式：通过class那么调用、通过Object调用Account::set_rate(5.0);// 4.注意：通过Object调用，但是不会将对象地址当做参数this，函数体内不能使用this指针Account a;a.set_rate(7.0);
}

三、Object Oriented（面向对象）：学习Classes之间的关系

1.复合（composition）表示`has-a`

a.什么是复合关系？

复合关系

//Adapter
template <class T>
class queue
{...
protected:deque<T> c; //底层容器
public://以下都是利用c的操作函数完成的bool empty() const {return c.empty();}size_type size() const {return c.size();}void push(const value_type & x){c.push_back(x);}...
};

b.composition【复合】关系下的构造和析构（内存角度分析）

复合关系的构造和析构

构造由内向外： container的构造函数首先调用component的default构造函数，后才执行自己

Container::Container(...) : Component() {...};

【注意】如果component需要参数，用户需要自己给构造函数

析构由外到内： container的析构函数首先执行自己，然后才调用component的析构函数

Container::~Container(...) {... ~Component()};

2.委托（Deletagion）–Composition by reference(pointer)

什么是委托关系？

委托关系

// String.hpp---Handle---定义
class StringRep;
class String
{
public:String();String(const char* s);String(const String& s);String &operator= (const String& s);~String();...
private:StringRep* rep;//pImpl-->通过指针实现函数定义
};// String.cpp---Body---实现"background: aliceblue"
#include "String.hpp"
namespace
{class StringRep{friend class String;StringRep(const char* s);~StringRep();int count;char* rep;};
}
String::String(){...}
...

3.继承（Inheritance）–表示`is-a`

a.什么是继承关系？

继承关系

struct _List_node_base
{_List_node_base* _M_next;_List_node_base* _M_prev;
};
template<typename _Tp>
struct _List_node: public _List_node_base	//public继承：这里只由数据的继承，父类没有函数
{_Tp _M_data;
}

b.Inheritance（继承）关系下的构造和析构（从内存角度分析）

继承关系下的构造和析构

构造由内到外：Derived的构造函数首先调用Base的default构造函数，然后执行自己

Derived::Derived(...) : Base() {...};

析构由外到内：Derived的析构函数首先执行自己，然后才调用Base的析构函数

【注意】base class的dtor必须是virtual，否则会出现undefined behavior

Derived::~Derived(...) {... ~Base()};

c.Inheritance（继承）with virtual functions（虚函数）

继承需要搭配虚函数才能达到强有力的效果，在继承关系中，父类中所有的东西都会被继承下来：数据被继承下来，占用了内存的一部分，函数被继承下来，是继承了调用权（子类可以调用父类的函数）

那么父类的函数，需不需要被重新定义呢？

从这个角度，父类的函数可以分为三种：

non-virtual函数（非虚函数）：你不希望derived class重新定义（override，复写）它；
virtual函数（虚函数）：你希望derived class重新定义（override）它，且你对它已有默认定义；
pure virtual函数（纯虚函数）：你希望derived class一定要重新定义（override）它，你对它没有默认定义；（注：其实纯虚函数可以由定义）

形状（shape）：世界上并没有叫形状的形状，只有椭圆等；形状是一个抽象的概念，那么可以在这个抽象的层次做些什么呢？（该如何思考呢？）

继承搭配虚函数-shape

bjectID()：在运行过程中，给每一个产生的对象一个ID，这个产生ID的过程，不管是椭圆还是方形，都是流水号，所以不需要让子类实现它，只需要父类定义它就可以了，那么把它定义为非虚函数
error()：在执行过程中，可能会报错，设计的父类可以给一个默认的报错形式；但是在设计椭圆或方形时，可能不同的子类可以由更好的报错形式，父类允许子类重新定义error（），所以父类定义为虚函数
draw()：这个必须要让所有的子类重新定义，因为父类不知道如何定义它，需要将它定义为纯虚函数

通过上述，可知继承要搭配虚函数才能达到最好的效果。

4.面向对象的几个应用（设计模式几种经典应用）

a.模板设计模式（Template Method）【Inheritance + virtual】

继承搭配虚函数使用：
场景：将关键执行部分延缓到子类中决定如何执行

模板设计模式-继承&虚函数

//模拟上边过程
#include<iostream>
using namespace std;class CDocument
{
public:void OnFileOpen(){//这是个算法，每个cout输出代表一个实际动作cout << "dialog..." << endl;cout << "check file status ..." << endl;cout << "open file..." << endl;Serialize();//调用cout << "close file..." << endl;cout << "update all views..." << endl;}virtual void Serialize() { };
};//
class CMyDoc : public CDocument
{
public:virtual void Serialize(){//只有应用程序本身才知道如何读取自己的文件（格式）cout << "CMyDoc::Serialize()" << endl;}
};//
int main()
{CMyDoc myDoc;//假设对应【File/Open】myDoc.OnFileOpen();
}