C++ 笔记（16）— 类和对象（类定义、类实例对象定义、访问类成员、类成员函数、类 public/private/protected 成员、类对象引用和指针）

1. 类的定义

类定义是以关键字 class 开头，后跟类的名称。并在它后面依次包含类名，一组放在 {} 内的成员属性和成员函数，以及结尾的分号。

类声明将类本身及其属性告诉编译器。类声明本身并不能改变程序的行为，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

例如，我们使用关键字 class 定义 Box 数据类型，如下所示：

class Box
{
   	// 成员属性
    double length;   // 盒子的长度
    double breadth;  // 盒子的宽度
    double height;   // 盒子的高度
    // 成员函数
    double getVolume(void); // 返回体积
};

有时候也会把类成员的函数叫做“方法”。

2. 类实例对象的定义

类相当于蓝图，仅声明类并不会对程序的执行产生影响。在程序执行阶段，对象是类的化身。要使用类的功能，通常需要创建其实例——对象，并通过对象访问成员方法和属性。

声明类的对象，就像声明基本类型的变量一样。

double pi= 3.1415; 
Box Box1;          // 声明 Box1，类型为 Box
Box Box2;          // 声明 Box2，类型为 Box

对象 Box1 和 Box2 都有它们各自的数据成员。

就像可以为其他类型（如 int ）动态分配内存一样，也可使用 new 为 Box 对象动态地分配内存：

int* a = new int; 
delete a; 
Box* box = new Box(); 
delete box; 

3. 访问类成员

类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问。示例：

#include <iostream>
using namespace std;
 
class Box
{
  public:
    double length;
    double width;
    double height;
};

int main()
{
  Box box1; // box1，类型为 Box
  Box box2;
  double volume = 0.0;

  box1.length = 1;
  box1.width = 2;
  box1.height = 3;

  box2.length = 4;
  box2.width = 5;
  box2.height = 6;

  volume = box1.length * box1.width * box1.height;
  cout << "box1 vloume is " << volume << endl;

  volume = box2.length * box2.width * box2.height;
  cout << "box2 vloume is " << volume << endl;

  return 0;
}

如果有一个指针 box，它指向 Box 类的一个实例，则可使用指针运算符 -> 来访问成员，也可使用间接运算符 * 来获取对象，再使用句点运算符来访问成员：

Box* box = new Box();
(*box).getVolume();

4. 类成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类内部定义中定义的成员函数把函数声明为内联的（关于内联，请参考https://www.runoob.com/w3cnote/cpp-inline-usage.html），即便没有使用 inline 标识符。

将成员函数的定义放在类定义内有两个作用:

• 函数将成为内联的 inline ，即编译器为此函数的调用生成代码时，不会生成真正的函数调用，而是将其代码嵌入到调用者的代码中 。 对于较小的函数，这种编译方式会带来很大的性能提升 ；
• 每当我们对内联函数体做出修改时， 所有使用这个类的程序都不得不重新编译；
• 如果函数体位于类声明之外，就不必这样 ，只在类接口改变时才需要重新编译用户程序，对于大程序来说，函数体改变时无须重新编译程序会是一个巨大的优势 。
• 类定义变大了 。 因此 ,在成员函数定义中找到成员会变得困难 。

显然，我们应遵循如下基本原则： 除非你明确需要从小函数的内联中获得性能提升，否
则不要将成员函数体放在类声明中 。

所以您可以按照如下方式定义 getVolume 函数：

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();  // 调用该对象的成员函数

使用上面提到的概念来设置和获取类中不同的成员的值：

#include <iostream>
using namespace std;
 
class Box
{
  public:
    double length;
    double width;
    double height;

    // 类成员函数声明
    double getVolume(void);
    void setLength(double len);
    void setWidth(double wid);
    void setHeight(double hei);
};

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

void Box::setHeight(double hei)
{
  height = hei;

}

void Box::setLength(double len)
{
  length = len;
}

void Box::setWidth(double wid)
{
  width = wid;
}

int main()
{
  Box box1; // box1，类型为 Box
  Box box2;
  double volume = 0.0;

  box1.setLength(1);
  box1.setWidth(2);
  box1.setHeight(3);

  box2.setLength(4);
  box2.setWidth(5);
  box2.setHeight(6);

  volume = box1.getVolume();
  cout << "box1 vloume is " << volume << endl;

  volume = box2.getVolume();
  cout << "box2 vloume is " << volume << endl;

  return 0;
}

5. 类访问修饰符

数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public 、 private 、 protected 来指定的。关键字 public 、 private 、 protected 称为访问修饰符。

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

一个类可以有多个 public 、 protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。

成员和类的默认访问修饰符是 private 。也就是说如下代码

class X 
{
	int func(int);
};

等价于

class X 
{
	private:
		int func(int);
};

5.1 公有（public）成员

公有成员在程序中类的外部是可访问的。可以不使用任何成员函数来设置和获取公有变量的值，如下所示：

#include <iostream>
using namespace std;
 
class Line
{
    public:
      double length;
      void setLength(double len);
      double getLength(void);
};
 
// 成员函数定义
double Line::getLength(void)
{
    return length;
}
 
void Line::setLength(double len)
{
    length = len;
}
 
// 程序的主函数
int main( )
{
   Line line;
 
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   // 不使用成员函数设置长度
   line.length = 10.0; // OK: 因为 length 是公有的
   cout << "Length of line : " << line.length <<endl;
   return 0;
}

5.2 私有（private）成员

私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。

默认情况下，类的所有成员都是私有的。例如在下面的类中， width 是一个私有成员，这意味着，如果您没有使用任何访问修饰符，类的成员将被假定为私有成员：

class Box
{
   double width;
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
};

实际操作中，我们一般会在私有区域定义数据，在公有区域定义相关的函数，以便在类的外部也可以调用这些函数，如下所示：

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

C++ 提供了一种很有用的简化功能 ，可用来描述没有私有实现细节的类，这种语法功能就是结构体 ( struct )，一个结构体就是一个成员默认为公有属性的类 。

struct People
{
    int age;
};

等价于

class People
{
    public:
        int age;
};

结构体主要用于成员可以取任意值的数据结构 。

5.3 保护（protected）成员

保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。

从下面的实例中，我们从父类 Box 派生了一个子类 smallBox。下面的实例与前面的实例类似，在这里 width 成员可被派生类 smallBox 的任何成员函数访问。

#include <iostream>
using namespace std;
 
class Box
{
   protected:
      double width;
};
 
class SmallBox:Box // SmallBox 是派生类
{
   public:
      void setSmallWidth( double wid );
      double getSmallWidth( void );
};
 
// 子类的成员函数
double SmallBox::getSmallWidth(void)
{
    return width ;
}
 
void SmallBox::setSmallWidth( double wid )
{
    width = wid;
}
 
// 程序的主函数
int main( )
{
   SmallBox box;
 
   // 使用成员函数设置宽度
   box.setSmallWidth(5.0);
   cout << "Width of box : "<< box.getSmallWidth() << endl;
 
   return 0;
}

6. 类对象引用

我们说引用就像是给变量起了一个别名，对这个引用的操作就和操作这个变量本身一样。
对象也可以有引用，声明一个对象的引用方法是:

类名 &对象名 a=对象名 b;

此时，对对象 a 的访问和操作就如同对对象 b 的访问和操作一样，对象 a 只是对象 b 的一个别名。

int main( )
{
   Box box; // 声明一个 box 对象
   Box &b = box;    // 声明一个 box 引用
   b.setWidth(1.0); // 效果与  box.setWidth(1.0) 相同
   b.getWidth();    // 效果与  box.getWidth 相同
   return 0;
}

7. 类对象指针

由于类和结构的相似性，对象指针和结构指针的使用也是相似的。我们也是使用箭头操作符 -> 来访问该指针所指向的对象的成员数据或成员函数。

int main( )
{
   Box box; // 声明一个 box 对象
   Box *b = &box;    // 声明一个对象指针
   b->setWidth(1.0); // 效果与  box.setWidth(1.0) 相同
   b->getWidth();    // 效果与  box.getWidth 相同
   return 0;
}

参考：
https://www.runoob.com/cplusplus/cpp-class-access-modifiers.html