c++ 类与对象(一)

c++ 类与对象总结

1. C++ 类定义

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据被称为成员变量，类中的函数被称为成员函数。

类可以看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

以下实例我们使用关键字 class 定义 Box 数据类型，包含了三个成员变量 length、breadth 和 height：

class Box
{
    public:
          double length;    // 长
    	  double breadth;   // 宽
    	  double height;    // 高
    
}

1.1 定义 C++ 对象

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

1.2 访问数据成员

类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问。私有的成员和受保护的成员不能使用直接成员访问运算符 . 来直接访问。

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
      // 成员函数声明
      double get(void);
      void set( double len, double bre, double hei );
};
// 成员函数定义
double Box::get(void)
{
    return length * breadth * height;
}
 
void Box::set( double len, double bre, double hei)
{
    length = len;
    breadth = bre;
    height = hei;
}
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 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;
 

   // box 2 详述
   Box2.set(16.0, 8.0, 12.0); 
   volume = Box3.get(); 
   cout << "Box3 的体积：" << volume <<endl;
   return 0;
}

Box1 的体积：210
Box2 的体积：1560
Box3 的体积：1536

1.3 类的成员函数

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义，在 :: 运算符之前必须使用类名 。

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

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

小结总结：

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

2. 成员函数可以单独使用范围解析运算符 **:: **来定义，在 :: 运算符之前必须使用类名

2. 类访问修饰符

数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。

关键字 public、private、protected 称为访问修饰符。

public: 公有成员

protected：受保护成员

private：私有成员

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

class Box
{
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
     
};
int main
{
Box box1;
box1.length = 10.0;
cout << "Length of box1 : " << box1.length <<endl;
return 0;
}

Length of box1 : 10

私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员, 如果您没有使用任何访问修饰符，类的成员将被假定为私有成员。

#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.width = 10.0; // Error: 因为 width 是私有的
   box.setWidth(10.0);  // 使用成员函数设置宽度 √
   cout << "Width of box : " << box.getWidth() <<endl;
 
   return 0;
}

Width of box : 10

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

**protected（受保护）**成员变量或函数可以在派生类的成员函数和友元函数中访问，但在类外部（如 main 函数）是无法直接访问的。

#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.width = 5.0;    // ×  在类外部protected成员是无法直接访问的。
   // 使用成员函数设置宽度
   box.setSmallWidth(5.0);
   cout << "Width of box : "<< box.getSmallWidth() << endl;
 
   return 0;
}

2.1 继承中的特点

具体参见本文

小结总结：

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

2. 成员函数可以单独使用范围解析运算符 **:: **来定义，在 :: 运算符之前必须使用类名

3. 继承可以使用class 子类 ： 继承方式 父类的方式来表示

   class SmallBox : private Box

   {

   }；

3. 类构造函数 & 析构函数

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

构造函数可以分为带参数的构造函数与不带参数的构造函数，带参数的构造函数可以使用初始化列表来初始化字段

3.1 不带参数的构造函数

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

Object is being created
Length of line : 6

3.2 带参数的构造函数

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

Object is being created, length = 10
Length of line : 10
Length of line : 6

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

上例的构造函数初始化为：

Line::Line( double len)
{
    cout << "Object is being created, length = " << len << endl;
    length = len;
}

等同于下例使用初始化列表来初始化字段：

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) 
{
	.... 
}

Line( double len)
{
cout << "Object is being created, length = " << len << endl;
length = len;
}

等同于下例使用初始化列表来初始化字段：

```c++
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) 
{
	.... 
}