C++学习笔记章节中 面向对象详解

C++ 类&对象

C++类定义

  • 本质上是一个数据类型的蓝图，定义了类的对象包含的信息，以及可以在这个类对象上执行哪些操作。
  • 类的定义是以class开头，后面接类的名称。
  • 类的主体是包含在一个花括号中，类的定义之后，必须跟着一个分号或者一个声明列表，例子：
  • 关键字public确定了类成员的访问属性，使得在类对象作用域中，公共成员在类的外部是可以被访问到的。也可以将其定位为private或者protected。
class Box
{public:double length;   // 盒子的长度double breadth;  // 盒子的宽度double height;   // 盒子的高度
};

类&对象详解

概念描述
类成员函数类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。
类访问修饰符类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。
构造函数 & 析构函数类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。
C++ 拷贝构造函数拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
C++ 友元函数友元函数可以访问类的 private 和 protected 成员。
C++ 内联函数通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。
C++ 中的 this 指针每个对象都有一个特殊的指针 this，它指向对象本身。
C++ 中指向类的指针指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
C++ 类的静态成员类的数据成员和函数成员都可以被声明为静态的。

类成员函数

  • 类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。
  • 需要使用成员函数来访问类的成员，而不是直接访问这些类的成员
  • 成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。按照如下方式定义 Volume() 函数：
class Box
{public:double length;      // 长度double breadth;     // 宽度double height;      // 高度double getVolume(void){return length * breadth * height;}
};
  • 也可以在类的外部使用范围解析运算符 :: 定义该函数，如下所示： 
double Box::getVolume(void)
{return length * breadth * height;
}
  •  :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据，如下所示：
Box myBox;          // 创建一个对象myBox.getVolume();  // 调用该对象的成员函数

访问修饰符

  • 关键字public、private和protected称之为访问修饰符

class Base {public:// 公有成员protected:// 受保护成员private:// 私有成员};
  • 公有成员在程序中类的外部是可访问的。可以不使用任何成员函数来设置和获取公有变量的值
  • 私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。默认情况下，类的所有成员都是私有的。例如在下面的类中，width 是一个私有成员，这意味着，如果没有使用任何访问修饰符，类的成员将被假定为私有成员。
  • 一般会在私有区域定义数据，在公有区域定义相关的函数，以便在类的外部也可以调用这些函数
#include <iostream>using namespace std;class Box
{public:double length;void setWidth( double wid );double getWidth( void );private:double width;
};// 成员函数定义
double Box::getWidth(void)
{return width ;
}void Box::setWidth( double wid )
{width = wid;
}// 程序的主函数
int main( )
{Box box;// 不使用成员函数设置长度box.length = 10.0; // OK: 因为 length 是公有的cout << "Length of box : " << box.length <<endl;// 不使用成员函数设置宽度// box.width = 10.0; // Error: 因为 width 是私有的box.setWidth(10.0);  // 使用成员函数设置宽度cout << "Width of box : " << box.getWidth() <<endl;return 0;
}

  • 保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。例子中，从父类 Box 派生了一个子类 smallBox。在这里 width 成员可被派生类 smallBox 的任何成员函数访问。

继承中的特点

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

  • public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private
  • protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private
  • private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，上面两点都没有改变：

  • private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；
  • protected 成员可以被派生类访问。
  • 默认使用protected继承，在struct中默认使用public继承
继承方式基类的public成员基类的protected成员基类的private成员继承引起的访问控制关系变化概括
public继承仍为public成员仍为protected成员不可见基类的非私有成员在子类的访问属性不变
protected继承变为protected成员变为protected成员不可见基类的非私有成员都为子类的保护成员
private继承变为private成员变为private成员不可见基类中的非私有成员都称为子类的私有成员

类构造函数 & 析构函数

类的构造函数

  • 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
  • 构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
#include <iostream>using namespace std;class Line
{public:void setLength( double len );double getLength( void );Line();  // 这是构造函数private:double length;
};// 成员函数定义，包括构造函数
Line::Line(void)
{cout << "Object is being created" << endl;
}void Line::setLength( double len )
{length = len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;return 0;
}

带参数的构造函数

  • 默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：
#include <iostream>using namespace std;class Line
{public:void setLength( double len );double getLength( void );Line(double len);  // 这是构造函数private:double length;
};// 成员函数定义，包括构造函数
Line::Line( double len)
{cout << "Object is being created, length = " << len << endl;length = len;
}void Line::setLength( double len )
{length = len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line(10.0);// 获取默认设置的长度cout << "Length of line : " << line.getLength() <<endl;// 再次设置长度line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl;return 0;
}

使用初始化列表来初始化字段

  • 使用初始化列表来初始化字段：
Line::Line( double len): length(len)
{cout << "Object is being created, length = " << len << endl;
}
  • 等效于以下的语法
Line::Line( double len)
{length = len;cout << "Object is being created, length = " << len << endl;
}
  • 假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：
C::C( double a, double b, double c): X(a), Y(b), Z(c)
{....
}

类的析构函数

  • 类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
  • 析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

  • 通过使用另一个同类型的对象来初始化新创建的对象。
  • 复制对象把它作为参数传递给函数。
  • 复制对象，并从函数返回这个对象。

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：

classname (const classname &obj) {// 构造函数的主体
}
  • obj 是一个对象引用，该对象是用于初始化另一个对象的
#include <iostream>using namespace std;class Line{public:int getLength(void);Line(int len);//简单的构造函数Line(const Line &Obj);//拷贝构造函数~Line();//析构函数private:int *ptr;
};//成员函数的定义，包括析构函数
Line::Line(int len) {cout<<"调用构造函数"<<endl;//为指针分配内存ptr = new int;*ptr = len;
}
Line::Line(const Line &Obj) {cout<<" 调用拷贝构造函数并且为指针ptr分配内存 "<<endl;ptr = new int;*ptr = *Obj.ptr;//拷贝值
}
Line::~Line() {cout<<"释放内存"<<endl;delete ptr;
}
int Line::getLength(void) {return *ptr;
}
void display(Line obj){cout<<"line 大小"<<obj.getLength()<<endl;
}
int main(){Line line(10);display(line);return 0;
}
  • 使用已有的同类型的对象来初始化新创建的对象
int main(){Line line1(10);Line line2 = line1;//这里调用了拷贝构造函数display(line1);display(line2);return 0;
}

C++ 友元函数

  • 类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。
  • 友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。
  • 如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend，如下所示：
class Box
{double width;
public:double length;friend void printWidth( Box box );void setWidth( double wid );
};

例子：

#include <iostream>using namespace std;class Box
{double width;
public:friend void printWidth( Box box );void setWidth( double wid );
};// 成员函数定义
void Box::setWidth( double wid )
{width = wid;
}// 请注意：printWidth() 不是任何类的成员函数
void printWidth( Box box )
{/* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */cout << "Width of box : " << box.width <<endl;
}// 程序的主函数
int main( )
{Box box;// 使用成员函数设置宽度box.setWidth(10.0);// 使用友元函数输出宽度printWidth( box );return 0;
}

C++内联函数

  • C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。
  • 对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inline 限定符。在类定义中的定义的函数都是内联函数，即使没有用 inline 说明符。

this指针

  • 每一个对象都可以通过使用this指针来访问自己的地址，this是一个所有成员函数的隐含参数，因此，在成员函数内部，可以用来指向调用对象。
  • 友元函数没有this指针，因为友元不是类的成员，只有成员才可以使用this指针。
#include <iostream>using namespace std;class Box
{public:// 构造函数定义Box(double l=2.0, double b=2.0, double h=2.0){cout <<"Constructor called." << endl;length = l;breadth = b;height = h;}double Volume(){return length * breadth * height;}int compare(Box box){return this->Volume() > box.Volume();}private:double length;     // Length of a boxdouble breadth;    // Breadth of a boxdouble height;     // Height of a box
};int main(void)
{Box Box1(3.3, 1.2, 1.5);    // Declare box1Box Box2(8.5, 6.0, 2.0);    // Declare box2if(Box1.compare(Box2)){cout << "Box2 is smaller than Box1" <<endl;}else{cout << "Box2 is equal to or larger than Box1" <<endl;}return 0;
}

指向类的指针

  • 一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 ->，就像访问指向结构的指针一样。与所有的指针一样，您必须在使用指针之前，对指针进行初始化。
#include <iostream>using namespace std;class Box
{public:// 构造函数定义Box(double l=2.0, double b=2.0, double h=2.0){cout <<"Constructor called." << endl;length = l;breadth = b;height = h;}double Volume(){return length * breadth * height;}private:double length;     // Length of a boxdouble breadth;    // Breadth of a boxdouble height;     // Height of a box
};int main(void)
{Box Box1(3.3, 1.2, 1.5);    // Declare box1Box Box2(8.5, 6.0, 2.0);    // Declare box2Box *ptrBox;                // Declare pointer to a class.// 保存第一个对象的地址ptrBox = &Box1;// 现在尝试使用成员访问运算符来访问成员cout << "Volume of Box1: " << ptrBox->Volume() << endl;// 保存第二个对象的地址ptrBox = &Box2;// 现在尝试使用成员访问运算符来访问成员cout << "Volume of Box2: " << ptrBox->Volume() << endl;return 0;
}

C++ 类的静态成员

  • 使用 static 关键字来把类成员定义为静态的。当声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。
  • 静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化

静态成员函数

  • 如果把函数成员声明为静态的，就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用，静态函数只要使用类名加范围解析运算符 :: 就可以访问。
  • 静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。
  • 静态成员函数有一个类范围，他们不能访问类的 this 指针。您可以使用静态成员函数来判断类的某些对象是否已被创建。

静态成员函数与普通成员函数的区别：

  • 静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
  • 普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针。

C++ 继承

  • 面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。
  • 当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。
  • 继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

基类 & 派生类

  • 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：
class derived-class: access-specifier base-class
  • 其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

假设有一个基类 Shape，Rectangle 是它的派生类，如下所示：

#include <iostream>using namespace std;// 基类
class Shape 
{public:void setWidth(int w){width = w;}void setHeight(int h){height = h;}protected:int width;int height;
};// 派生类
class Rectangle: public Shape
{public:int getArea(){ return (width * height); }
};int main(void)
{Rectangle Rect;Rect.setWidth(5);Rect.setHeight(7);// 输出对象的面积cout << "Total area: " << Rect.getArea() << endl;return 0;
}

访问控制和继承

  • 派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。可以根据访问权限总结出不同的访问类型，如下所示：
访问publicprotectedprivate
同一个类yesyesyes
派生类yesyesno
外部的类yesnono

一个派生类继承了所有的基类方法，但下列情况除外：

  • 基类的构造函数、析构函数和拷贝构造函数
  • 基类的重载运算符
  • 基类的友元函数

继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

  • 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
  • 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
  • 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

多继承

  • 多继承即一个子类可以有多个父类，它继承了多个父类的特性。
  • C++ 类可以从多个类继承成员，语法如下：
class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。现在一起看看下面的实例：

#include <iostream>using namespace std;// 基类 Shape
class Shape 
{public:void setWidth(int w){width = w;}void setHeight(int h){height = h;}protected:int width;int height;
};// 基类 PaintCost
class PaintCost 
{public:int getCost(int area){return area * 70;}
};// 派生类
class Rectangle: public Shape, public PaintCost
{public:int getArea(){ return (width * height); }
};int main(void)
{Rectangle Rect;int area;Rect.setWidth(5);Rect.setHeight(7);area = Rect.getArea();// 输出对象的面积cout << "Total area: " << Rect.getArea() << endl;// 输出总花费cout << "Total paint cost: $" << Rect.getCost(area) << endl;return 0;
}

另外多继承(环状继承)

  • A->D, B->D, C->(A，B)
class D{......};
class B: public D{......};
class A: public D{......};
class C: public B, public A{.....};
  • 这个继承会使D创建两个对象,要解决上面问题就要用虚拟继承格式。格式：class 类名: virtual 继承方式 父类名
class D{......};
class B: virtual public D{......};
class A: virtual public D{......};
class C: public B, public A{.....};

例子

#include <iostream>using namespace std;
//基类class D
{
public:D(){cout<<"D()"<<endl;}~D(){cout<<"~D()"<<endl;}
protected:int d;
};class B:virtual public D
{
public:B(){cout<<"B()"<<endl;}~B(){cout<<"~B()"<<endl;}
protected:int b;
};class A:virtual public D
{
public:A(){cout<<"A()"<<endl;}~A(){cout<<"~A()"<<endl;}
protected:int a;
};class C:public B, public A
{
public:C(){cout<<"C()"<<endl;}~C(){cout<<"~C()"<<endl;}
protected:int c;
};int main()
{cout << "Hello World!" << endl;C c;   //D, B, A ,Ccout<<sizeof(c)<<endl;return 0;
}

注意事项

  • 与类同名的函数是构造函数。
  • ~ 类名的是类的析构函数。

重载运算符和重载函数

  • C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。
  • 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。
  • 当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

C++ 中的函数重载

  • 在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。不能仅通过返回类型的不同来重载函数。
  • 下面的实例中，同名函数 print() 被用于输出不同的数据类型：
#include <iostream>
using namespace std;class printData
{public:void print(int i) {cout << "整数为: " << i << endl;}void print(double  f) {cout << "浮点数为: " << f << endl;}void print(char c[]) {cout << "字符串为: " << c << endl;}
};int main(void)
{printData pd;// 输出整数pd.print(5);// 输出浮点数pd.print(500.263);// 输出字符串char c[] = "Hello C++";pd.print(c);return 0;
}

C++ 中的运算符重载

  • 可以重定义或重载大部分 C++ 内置的运算符。这样，就可以使用自定义类型的运算符。
  • 重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。
Box operator+(const Box&);
声明加法运算符用于把两个 Box 对象相加，返回最终的 Box 对象。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。如果我们定义上面的函数为类的非成员函数，那么我们需要为每次操作传递两个参数，如下所示：
Box operator+(const Box&, const Box&);
  • 下面的实例使用成员函数演示了运算符重载的概念。在这里，对象作为参数进行传递，对象的属性使用 this 运算符进行访问，如下所示：
#include <iostream>
using namespace std;class Box
{public:double getVolume(void){return length * breadth * height;}void setLength( double len ){length = len;}void setBreadth( double bre ){breadth = bre;}void setHeight( double hei ){height = hei;}// 重载 + 运算符，用于把两个 Box 对象相加Box operator+(const Box& b){Box box;box.length = this->length + b.length;box.breadth = this->breadth + b.breadth;box.height = this->height + b.height;return box;}private:double length;      // 长度double breadth;     // 宽度double height;      // 高度
};
// 程序的主函数
int main( )
{Box Box1;                // 声明 Box1，类型为 BoxBox Box2;                // 声明 Box2，类型为 BoxBox Box3;                // 声明 Box3，类型为 Boxdouble volume = 0.0;     // 把体积存储在该变量中// Box1 详述Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0);// Box2 详述Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0);// Box1 的体积volume = Box1.getVolume();cout << "Volume of Box1 : " << volume <<endl;// Box2 的体积volume = Box2.getVolume();cout << "Volume of Box2 : " << volume <<endl;// 把两个对象相加，得到 Box3Box3 = Box1 + Box2;// Box3 的体积volume = Box3.getVolume();cout << "Volume of Box3 : " << volume <<endl;return 0;
}

可重载运算符

双目算术运算符+ (加)，-(减)，*(乘)，/(除)，% (取模)
关系运算符==(等于)，!= (不等于)，< (小于)，> (大于>，<=(小于等于)，>=(大于等于)
逻辑运算符||(逻辑或)，&&(逻辑与)，!(逻辑非)
单目运算符+ (正)，-(负)，*(指针)，&(取地址)
自增自减运算符++(自增)，--(自减)
位运算符| (按位或)，& (按位与)，~(按位取反)，^(按位异或),，<< (左移)，>>(右移)
赋值运算符=, +=, -=, *=, /= , % = , &=, |=, ^=, <<=, >>=
空间申请与释放new, delete, new[ ] , delete[]
其他运算符()(函数调用)，->(成员访问)，,(逗号)，[](下标)

不可重载运算符

  • .：成员访问运算符
  • .*, ->*：成员指针访问运算符
  • ::：域运算符
  • sizeof：长度运算符
  • ?:：条件运算符
  • #： 预处理符号

运算符重载的案例

序号运算符和实例
1一元运算符重载
2二元运算符重载
3关系运算符重载
4输入/输出运算符重载
5++ 和 -- 运算符重载
6赋值运算符重载
7函数调用运算符 () 重载
8下标运算符 [] 重载
9类成员访问运算符 -> 重载

一元运算符重载

 

一元运算符只对一个操作数进行操作，下面是一元运算符的实例：

  • 递增运算符（ ++ ）和递减运算符（ -- ）
  • 一元减运算符，即负号（ - ）
  • 逻辑非运算符（ ! ）

一元运算符通常出现在它们所操作的对象的左边，比如 !obj、-obj 和 ++obj，但有时它们也可以作为后缀，比如 obj++ 或 obj--。下面的实例演示了如何重载一元减运算符（ - ）。

二元运算符重载

  • 二元运算符需要两个参数，下面是二元运算符的实例。平常使用的加运算符（ + ）、减运算符（ - ）、乘运算符（ * ）和除运算符（ / ）都属于二元运算符。就像加(+)运算符。
  • 下面的实例演示了如何重载加运算符（ + ）
#include <iostream>
using namespace std;class Box
{double length;      // 长度double breadth;     // 宽度double height;      // 高度
public:double getVolume(void){return length * breadth * height;}void setLength( double len ){length = len;}void setBreadth( double bre ){breadth = bre;}void setHeight( double hei ){height = hei;}// 重载 + 运算符，用于把两个 Box 对象相加Box operator+(const Box& b){Box box;box.length = this->length + b.length;box.breadth = this->breadth + b.breadth;box.height = this->height + b.height;return box;}
};
// 程序的主函数
int main( )
{Box Box1;                // 声明 Box1，类型为 BoxBox Box2;                // 声明 Box2，类型为 BoxBox Box3;                // 声明 Box3，类型为 Boxdouble volume = 0.0;     // 把体积存储在该变量中// Box1 详述Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0);// Box2 详述Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0);// Box1 的体积volume = Box1.getVolume();cout << "Volume of Box1 : " << volume <<endl;// Box2 的体积volume = Box2.getVolume();cout << "Volume of Box2 : " << volume <<endl;// 把两个对象相加，得到 Box3Box3 = Box1 + Box2;// Box3 的体积volume = Box3.getVolume();cout << "Volume of Box3 : " << volume <<endl;return 0;
}

关系运算符重载

  • C++ 语言支持各种关系运算符（ < 、 > 、 <= 、 >= 、 == 等等），它们可用于比较 C++ 内置的数据类型
  • 可以重载任何一个关系运算符，重载后的关系运算符可用于比较类的对象。
  • 下面的实例演示了如何重载 < 运算符

输入/输出运算符重载

  • C++ 能够使用流提取运算符 >> 和流插入运算符 << 来输入和输出内置的数据类型。可以重载流提取运算符和流插入运算符来操作对象等用户自定义的数据类型。
  • 在这里，有一点很重要，我们需要把运算符重载函数声明为类的友元函数，这样我们就能不用创建对象而直接调用函数。
  • 下面的实例演示了如何重载提取运算符 >> 和插入运算符 <<。

C++多态

  • 多态，按照字面意思是指多种形态。当类之间存在层次结构的时候，并且类之间是通过继承关系关联的时候，就会遇到多态。多态是指调用成员函数的时候，会根据调用函数的对象的类型不同来执行不同的函数。
  • 例子：基类shape会被派生为两个类
#include <iostream> 
using namespace std;class Shape {protected:int width, height;public:Shape( int a=0, int b=0){width = a;height = b;}int area(){cout << "Parent class area :" <<endl;return 0;}
};
class Rectangle: public Shape{public:Rectangle( int a=0, int b=0):Shape(a, b) { }int area (){ cout << "Rectangle class area :" <<endl;return (width * height); }
};
class Triangle: public Shape{public:Triangle( int a=0, int b=0):Shape(a, b) { }int area (){ cout << "Triangle class area :" <<endl;return (width * height / 2); }
};
// 程序的主函数
int main( )
{Shape *shape;Rectangle rec(10,7);Triangle  tri(10,5);// 存储矩形的地址shape = &rec;// 调用矩形的求面积函数 areashape->area();// 存储三角形的地址shape = &tri;// 调用三角形的求面积函数 areashape->area();return 0;
}//Parent class area
//Parent class area
  • 出现上面的错误原因是：

    调用函数 area() 被编译器设置为基类中的版本，这就是所谓的静态多态，或静态链接 - 函数调用在程序执行前就准备好了。有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。

  • 正确的使用方法：在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示：

class Shape {protected:int width, height;public:Shape( int a=0, int b=0){width = a;height = b;}virtual int area(){cout << "Parent class area :" <<endl;return 0;}
};

虚函数

  • 虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。
  • 在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

纯虚函数

  • 在基类中定义虚函数，以便在派生类中重新定义该函数从而更好地适用于对象，但是在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。
  • 可以把基类中的虚函数 area() 改写如下：
class Shape {protected:int width, height;public:Shape( int a=0, int b=0){width = a;height = b;}// pure virtual functionvirtual int area() = 0;
};

  • = 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

C++ 数据抽象

  • 数据抽象是指，只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节，这个依赖于接口和实现相互分离的编程（设计）技术。
  • 举一个现实生活中的真实例子，比如一台电视机，用户可以打开和关闭、切换频道、调整音量、添加外部组件（如喇叭、录像机、DVD 播放器），但是不知道它的内部实现细节，也就是说，并不知道它是如何通过缆线接收信号，如何转换信号，并最终显示在屏幕上。因此，可以说电视把它的内部实现和外部接口分离开了，无需知道它的内部实现原理，直接通过它的外部接口（比如电源按钮、遥控器、声量控制器）就可以操控电视。
  • 就 C++ 编程而言，C++ 类为数据抽象提供了可能。它向外界提供了大量用于操作对象数据的公共方法，也就是说，外界实际上并不清楚类的内部实现。例如，程序可以调用 sort() 函数，而不需要知道函数中排序数据所用到的算法。实际上，函数排序的底层实现会因库的版本不同而有所差异，只要接口不变，函数调用就可以照常工作。
  • 在 C++ 中，可以使用类来定义用户自己的抽象数据类型（ADT）。可以使用类 iostream 的 cout 对象来输出数据到标准输出，如下所示：
#include <iostream>
using namespace std;int main( )
{cout << "Hello C++" <<endl;return 0;
}
  • 不需要理解 cout 是如何在用户的屏幕上显示文本。只需要知道公共接口即可，cout 的底层实现可以自由改变。

访问标签强制抽象

在 C++ 中，可以使用访问标签来定义类的抽象接口。一个类可以包含零个或多个访问标签：

  • 使用公共标签定义的成员都可以访问该程序的所有部分。一个类型的数据抽象视图是由它的公共成员来定义的。
  • 使用私有标签定义的成员无法访问到使用类的代码。私有部分对使用类型的代码隐藏了实现细节。

访问标签出现的频率没有限制。每个访问标签指定了紧随其后的成员定义的访问级别。指定的访问级别会一直有效，直到遇到下一个访问标签或者遇到类主体的关闭右括号为止。

数据抽象的好处

数据抽象有两个重要的优势：

  • 类的内部受到保护，不会因无意的用户级错误导致对象状态受损。
  • 类实现可能随着时间的推移而发生变化，以便应对不断变化的需求，或者应对那些要求不改变用户级代码的错误报告。

如果只在类的私有部分定义数据成员，编写该类的作者就可以随意更改数据。如果实现发生改变，则只需要检查类的代码，看看这个改变会导致哪些影响。如果数据是公有的，则任何直接访问旧表示形式的数据成员的函数都可能受到影响。

数据抽象的实例

  • C++ 程序中，任何带有公有和私有成员的类都可以作为数据抽象的实例。请看下面的实例：
#include <iostream>
using namespace std;class Adder{public:// 构造函数Adder(int i = 0){total = i;}// 对外的接口void addNum(int number){total += number;}// 对外的接口int getTotal(){return total;};private:// 对外隐藏的数据int total;
};
int main( )
{Adder a;a.addNum(10);a.addNum(20);a.addNum(30);cout << "Total " << a.getTotal() <<endl;return 0;
}
  • 上面的类把数字相加，并返回总和。公有成员 addNum 和 getTotal 是对外的接口，用户需要知道它们以便使用类。私有成员 total 是用户不需要了解的，但又是类能正常工作所必需的。

设计策略

  • 抽象把代码分离为接口和实现。所以在设计组件时，必须保持接口独立于实现，这样，如果改变底层实现，接口也将保持不变。在这种情况下，不管任何程序使用接口，接口都不会受到影响，只需要将最新的实现重新编译即可。

C++ 数据封装

所有的 C++ 程序都有以下两个基本要素：

  • 程序语句（代码）：这是程序中执行动作的部分，它们被称为函数。
  • 程序数据：数据是程序的信息，会受到程序函数的影响。

总结：

  1. 封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。数据封装引申出了另一个重要的 OOP 概念，即数据隐藏。
  2. 数据封装是一种把数据和操作数据的函数捆绑在一起的机制，数据抽象是一种仅向用户暴露接口而把具体的实现细节隐藏起来的机制。
  3. C++ 通过创建类来支持封装和数据隐藏（public、protected、private）。我们已经知道，类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。默认情况下，在类中定义的所有项目都是私有的。例如：
class Box
{public:double getVolume(void){return length * breadth * height;}private:double length;      // 长度double breadth;     // 宽度double height;      // 高度
};
  • 变量 length、breadth 和 height 都是私有的（private）。这意味着它们只能被 Box 类中的其他成员访问，而不能被程序中其他部分访问。这是实现封装的一种方式。
  • 为了使类中的成员变成公有的（即，程序中的其他部分也能访问），必须在这些成员前使用 public 关键字进行声明。所有定义在 public 标识符后边的变量或函数可以被程序中所有其他的函数访问。
  • 把一个类定义为另一个类的友元类，会暴露实现细节，从而降低了封装性。理想的做法是尽可能地对外隐藏每个类的实现细节。

  • C++中, 虚函数可以为private, 并且可以被子类覆盖（因为虚函数表的传递），但子类不能调用父类的private虚函数。虚函数的重载性和它声明的权限无关。一个成员函数被定义为private属性，标志着其只能被当前类的其他成员函数(或友元函数)所访问。而virtual修饰符则强调父类的成员函数可以在子类中被重写，因为重写的时候并没有与父类发生任何的调用关系，故而重写是被允许的。

    编译器不检查虚函数的各类属性。被virtual修饰的成员函数，不论他们是private、protect或是public的，都会被统一的放置到虚函数表中。对父类进行派生时，子类会继承到拥有相同偏移地址的虚函数表（相同偏移地址指，各虚函数相对于VPTR指针的偏移），则子类就会被允许对这些虚函数进行重载。且重载时可以给重载函数定义新的属性，例如public，其只标志着该重载函数在该子类中的访问属性为public，和父类的private属性没有任何关系！

    纯虚函数可以设计成私有的，不过这样不允许在本类之外的非友元函数中直接调用它，子类中只有覆盖这种纯虚函数的义务，却没有调用它的权利。

C++ 接口（抽象类）

  • 接口描述了类的行为和功能，而不需要完成类的特定实现。
  • C++ 接口是使用抽象类来实现的，抽象类与数据抽象互不混淆，数据抽象是一个把实现细节与相关的数据分离开的概念。
  • 如果类中有一个函数被声明为纯虚函数，则这个类就是抽象类。纯虚函数是通过在声明中使用 "= 0" 来指定的，如下所示：
class Box
{public:// 纯虚函数virtual double getVolume() = 0;private:double length;      // 长度double breadth;     // 宽度double height;      // 高度
};
  • 设计抽象类（通常称为 ABC）的目的，是为了给其他类提供一个可以继承的适当的基类。抽象类不能被用于实例化对象，它只能作为接口使用。如果试图实例化一个抽象类的对象，会导致编译错误。
  • 因此，如果一个 ABC 的子类需要被实例化，则必须实现每个虚函数，这也意味着 C++ 支持使用 ABC 声明接口。如果没有在派生类中重写纯虚函数，就尝试实例化该类的对象，会导致编译错误。
  • 可用于实例化对象的类被称为具体类。

抽象类的实例

  • 请看下面的实例，基类 Shape 提供了一个接口 getArea()，在两个派生类 Rectangle 和 Triangle 中分别实现了 getArea()：
#include <iostream>using namespace std;// 基类
class Shape 
{
public:// 提供接口框架的纯虚函数virtual int getArea() = 0;void setWidth(int w){width = w;}void setHeight(int h){height = h;}
protected:int width;int height;
};// 派生类
class Rectangle: public Shape
{
public:int getArea(){ return (width * height); }
};
class Triangle: public Shape
{
public:int getArea(){ return (width * height)/2; }
};int main(void)
{Rectangle Rect;Triangle  Tri;Rect.setWidth(5);Rect.setHeight(7);// 输出对象的面积cout << "Total Rectangle area: " << Rect.getArea() << endl;Tri.setWidth(5);Tri.setHeight(7);// 输出对象的面积cout << "Total Triangle area: " << Tri.getArea() << endl; return 0;
}

设计策略

  • 面向对象的系统可能会使用一个抽象基类为所有的外部应用程序提供一个适当的、通用的、标准化的接口。然后，派生类通过继承抽象基类，就把所有类似的操作都继承下来。
  • 外部应用程序提供的功能（即公有函数）在抽象基类中是以纯虚函数的形式存在的。这些纯虚函数在相应的派生类中被实现。这个架构也使得新的应用程序可以很容易地被添加到系统中，即使是在系统被定义之后依然可以如此。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/447107.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Mac 破解软件打不开没有权限

Mac 破解软件打不开没有权限

Mac 破解软件打不开没有权限 sudo codesign -fs - /Applications/CleanMyMac\ X.app文件损坏 xxx sudo xattr -r -d /Applications/MarginNote\ 3.app sudo xattr -r -d com.apple.quarantine xxxx sudo codesign --force --deep --sign - /Applications/MarginNote\ 3\…
阅读更多...
条件变量之虚假唤醒

条件变量之虚假唤醒

当线程从等待已发出信号的条件变量中醒来&#xff0c;却发现它等待的条件不满足时&#xff0c;就会发生虚假唤醒。之所以称为虚假&#xff0c;是因为该线程似乎无缘无故地被唤醒了。但是虚假唤醒不会无缘无故发生&#xff1a;它们通常是因为在发出条件变量信号和等待线程最终运…
阅读更多...
拷贝构造函数和拷贝赋节省代码最好用一个私有的函数

拷贝构造函数和拷贝赋节省代码最好用一个私有的函数

令 copy assignment操作符调用copy构造函数是不合理的&#xff0c;因为这就像试图构造一个已经存在的对象。这件事如此荒涔&#xff0c;乃至于根本没有相关语法。是有一些看似如你所愿的语法&#xff0c;但其实不是&#xff1b;也的确有些语法背后真正做了它&#xff0c;但它们…
阅读更多...
解决Dr.com上不了网的问题

解决Dr.com上不了网的问题

如果软件安装之后上不了网&#xff0c;会显示出错的信息&#xff0c;可以针对所显示的问题&#xff0c;去定向搜索。 如果是软件自身的问题&#xff0c;进入终端页面&#xff0c;可以使用一下这条命令 netsh winsock reset 然后需要重启电脑
阅读更多...
terminate called after throwing an instance of ‘std::logic_error‘ what(): basic_string::_M_constr

terminate called after throwing an instance of ‘std::logic_error‘ what(): basic_string::_M_constr

terminate called after throwing an instance of ‘std::logic_error’ what(): basic_string::_M_construct null not valid 用0初始化字符串 编译不报错
阅读更多...
密钥协商（密钥交换）机制的讲解

密钥协商（密钥交换）机制的讲解

国标文件涉及密钥协商算法的函数 生成密钥协商参数并输出计算会话密钥产生协商数据并且计算会话密钥 密钥协商&#xff08;交换&#xff09;算法及其原理 密钥交换/协商目的 “密钥协商机制”是&#xff1a;&#xff08;在身份认证的前提下&#xff09;规避【偷窥】的风险。…
阅读更多...
基于ECC算法的秘钥协商

基于ECC算法的秘钥协商

基于ECC算法的衍生算法 ECDH(ECCDH)RSAECDHE(ECCDHE) ECDH密钥协商&#xff08;ECCDH&#xff09; 椭圆曲线密码学是属于非对称密码学的&#xff0c;其私钥的计算公式如下&#xff1a; 私钥是一个随机数d&#xff0c;取值范围在1……n-1,其中n是子群的阶公钥是点HdG&#xff…
阅读更多...
C++11 多线程相关知识的学习

C++11 多线程相关知识的学习

C多线程类Thread&#xff08;C11&#xff09; C11中std命名空间将Boost库中的Thread加入&#xff0c;Boost的多线程从准标准变为标准&#xff0c;这里将其用法整理复习&#xff0c;以demo的形式复习&#xff0c;还是喜欢看我自己写的东西&#xff0c;符合我的个人逻辑头文件为…
阅读更多...
vscode vim 插件自定义配置

vscode vim 插件自定义配置

{"workbench.colorTheme": "Material Theme","files.defaultLanguage": "markdown", //新建文档格式为markdown格式"vim.easymotion": true,"vim.leader": " ", // leader键"vim.useSystemClipbo…
阅读更多...
C++11 explicit关键字的作用

C++11 explicit关键字的作用

explicit 在C中&#xff0c;explicit关键字用来修饰类的构造函数&#xff0c;被修饰的构造函数的类&#xff0c;不能发生相应的隐式类型转换&#xff0c;只能以显示的方式进行类型转换。因为无参构造函数和多参构造函数本身就是显示调用的。再加上explicit关键字也没有什么意义…
阅读更多...
c++ 指针的强制类型转换

c++ 指针的强制类型转换

#include <iostream> using namespace std; class A { public:int i;int j;A(int n):i(n),j(n) { } }; int F2 (int,char *){return 1; }; int F1 (int){return 2; }; int main() {A a(100);int &r reinterpret_cast<int&>(a); //强行让 r 引用 ar 200; …
阅读更多...
C++11学习 virtual（虚函数）的用法

C++11学习 virtual（虚函数）的用法

Virtual虚函数 在面向对象的C语言中&#xff0c;虚函数&#xff08;virtual function&#xff09;是一个非常重要的概念。因为它充分体现了面向对象思想中的继承和多态性这两大特性&#xff0c;在C语言里应用极广。多态性&#xff1a;其含义就是多种形式&#xff1b;将具有继承…
阅读更多...
c++ const

c++ const

函数名称不单单是函数名 const 补充内容 还有 const 参数类型 函数后头const 只能在成员函数如果const对象 但是我没通过const成员函数 就会报错
阅读更多...
C++11学习 新特性之 “=default” 、“=delete”

C++11学习 新特性之 “=default” 、“=delete”

文章目录 1、 default 和delete 概述2、 类与默认函数3、 使用“delete”来限制函数生成4、 “default”使用范围 1、 default 和delete 概述 default、delete 是C11的新特性&#xff0c;分别为&#xff1a;显式缺省(告知编译器生成函数默认的缺省版本)和显式删除(告知编译器…
阅读更多...
C++学习 优雅的实现对象到文件的序列化/反序列化 关键字serialize

C++学习 优雅的实现对象到文件的序列化/反序列化 关键字serialize

需要使用到序列化场景的需求 在写代码的过程中&#xff0c;经常会需要把代码层面的对象数据保存到文件&#xff0c;而这些数据会以各种格式存储&#xff0e;例如&#xff1a;json&#xff0c;xml&#xff0c;二进制等等&#xff0e;二进制&#xff0c;相比json&#xff0c;xml…
阅读更多...
c++堆栈溢出

c++堆栈溢出

阅读更多...
C++代码注释详解

C++代码注释详解

常用注释语法 注释写在对应的函数或变量前面。JavaDoc类型的多行注释风格如下&#xff1a; /** * 这里为注释. */ 一般注释中有简要注释和详细注释&#xff0c;简要注释有多种标识方式&#xff0c;这里推荐使用brief命令强制说明&#xff0c;例如&#xff1a;/** * brief 这里…
阅读更多...
段错误：SIGSEGV

段错误：SIGSEGV

SIGSEGV是在访问内存时发生的错误&#xff0c;它属于内存管理的范畴 SIGSEGV是一个用户态的概念&#xff0c;是操作系统在用户态程序错误访问内存时所做出的处理。 当用户态程序访问&#xff08;访问表示读、写或执行&#xff09;不允许访问的内存时&#xff0c;产生SIGSEGV。 …
阅读更多...
web3 0.2.x 和 1.x.x版本之间的差异

web3 0.2.x 和 1.x.x版本之间的差异

版本差异 单位转换 0.2.x web3.fromWei(13144321,ether) 1.x.x web3.utils.fromWei(13144321,ether)1.0以后的版本使用了大量的Promise&#xff0c;可以结合async/await使用&#xff0c;而0.20版本只支持回调函数
阅读更多...
如何提高阅读源码的能力并且手撕源码

如何提高阅读源码的能力并且手撕源码

怎么有效的手撕代码呢&#xff1f; 把代码跑起来把代码一个片段拿出来使用画出代码运行的流程图一行一行的搬运在看源码的情况下写出类似的demo
阅读更多...
最新文章

Copyright @ 2022~2023