C++ 面向对象 类&对象详解

C++类&对象

C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类类中的数据和方法称为类的成员。
类中的数据和方法称为类的成员。

1. 类定义
2. 定义C++对象
3. 访问数据成员
4. 类成员函数
5. 类访问修饰符
6. 构造函数与析构函数
7. C++拷贝构造函数
8. 友元函数
9. 内联函数
10. this指针
11. 指向类的指针
12. 静态函数

1.类定义

类定义是以关键字 class 开头，后跟类的名称。 类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。可以简单这样理解，比如学生这一类群体，他们有很多信息（姓名，学号，班级等等），而这些信息正是学生这一类的成员，看以下代码：

class Student
{
   public:
      double lD;   
      double ages;  
      char  name[10];
};

注意：关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。(后面修饰符会具体来讲)

2.定义C++对象

对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。

Box Box1;          // 声明 Box1，类型为 Box
Box Box2;          // 声明 Box2，类型为 Box

3.访问数据成员

类的对象的公共数据成员(使用关键字 public )可以使用直接成员访问运算符 " . " 来访问。

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
};
 
int main( )
{
   Box Box1;        // 声明 Box1，类型为 Box
   Box Box2;        // 声明 Box2，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
   // box 2 详述
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;
 
   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;
 
   // box 2 的体积
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的体积：" << volume <<endl;
   return 0;
}

4.类成员函数

描述：指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。
成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。所以可以按照如下方式定义 Volume() 函数：

class Box
{
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
   
      double getVolume(void)
      {
         return length * breadth * height;
      }
};

也可以在类的外部使用范围解析运算符 :: 定义该函数，不过需要在类中声明一下成员函数，如下所示：

class  Box
{
		double Box::getVolume(void);
}

double Box::getVolume(void)
{
    return length * breadth * height;
}

调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据

Box myBox;          // 创建一个对象
myBox.getVolume();  // 调用该对象的成员函数

5.类访问修饰符：

描述：一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。

class Base {
 
   public:
 
  // 公有成员
 
   protected:
 
  // 受保护成员
 
   private:
 
  // 私有成员
 
};

1.公有成员在程序中类的外部是可访问的。
2.私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。
3.保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。
看一下代码详解：

#include<iostream>
#include<assert.h>
using namespace std;

class A{
public:
  int a1;
  void change_a3(int num)
  {
      a3=num;
  }
  int get_a3()
  {
      return a3;
  }
protected:
  int a2;
private:
  int a3;
};
class B:public A{
public:
    void change_a2(int num)
    {
        a2=num;
    }
    int get_a2()
    {
        return a2;
    }
};
int main(){
  B b;
  b.a1=1;
  cout << b.a1 << endl;
  b.change_a3(2);
  cout <<b.get_a3()<<endl;
  b.change_a2(3);
  cout << b.get_a2()<<endl;

  return 0;
}

6.构造函数与析构函数

6.1类的构造函数是一种特殊的函数，在创建一个新的对象时调用。
构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      Line();  // 这是构造函数
};
 
// 构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
int main( )
{
   Line line;
   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;
}

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

#include <iostream>
using namespace std;
 
class Line
{
   public:
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}
 
// 程序的主函数
int main( )
{
   Line line;
   return 0;
}

7.C++拷贝构造函数

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

1.通过使用另一个同类型的对象来初始化新创建的对象。

2.复制对象把它作为参数传递给函数。

3.复制对象，并从函数返回这个对象。
拷贝构造函数的最常见形式如下：

classname (const classname &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(void)
{
    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;
}

8.友元函数

友元函数可以访问类的 private 和 protected 成员。
友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。
如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend，如下所示：

#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;
}

如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend。

9.内联函数

通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。
果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inline 限定符。在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。

#include <iostream>
 
using namespace std;

inline int Max(int x, int y)
{
   return (x > y)? x : y;
}

// 程序的主函数
int main( )
{

   cout << "Max (20,10): " << Max(20,10) << endl;
   cout << "Max (0,200): " << Max(0,200) << endl;
   cout << "Max (100,1010): " << Max(100,1010) << endl;
   return 0;
}

10.this指针

每个对象都有一个特殊的指针 this，它指向对象本身。
在 C++ 中，每一个对象都能通过 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 box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};
 
int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2
 
   if(Box1.compare(Box2))
   {
      cout << "Box2 is smaller than Box1" <<endl;
   }
   else
   {
      cout << "Box2 is equal to or larger than Box1" <<endl;
   }
   return 0;
}

11.指向类的指针

指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
个指向 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 box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};

int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box *ptrBox;                // Declare pointer to a class.

   // 保存第一个对象的地址
   ptrBox = &Box1;

   // 现在尝试使用成员访问运算符来访问成员
   cout << "Volume of Box1: " << ptrBox->Volume() << endl;
   return 0;
}

12.静态成员

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

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      static int objectCount;
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // 每次创建对象时增加 1
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};
 
// 初始化类 Box 的静态成员
int Box::objectCount = 0;
 
int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // 声明 box1
   Box Box2(8.5, 6.0, 2.0);    // 声明 box2
 
   // 输出对象的总数
   cout << "Total objects: " << Box::objectCount << endl;
 
   return 0;
}

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

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

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      static int objectCount;
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // 每次创建对象时增加 1
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      static int getCount()
      {
         return objectCount;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};
 
// 初始化类 Box 的静态成员
int Box::objectCount = 0;
 
int main(void)
{
  
   // 在创建对象之前输出对象的总数
   cout << "Inital Stage Count: " << Box::getCount() << endl;
 
   Box Box1(3.3, 1.2, 1.5);    // 声明 box1
   Box Box2(8.5, 6.0, 2.0);    // 声明 box2
 
   // 在创建对象之后输出对象的总数
   cout << "Final Stage Count: " << Box::getCount() << endl;
 
   return 0;
}