C++基础学习（2）——对象的定义和使用

二、 对象的定义和使用

1. 对象的定义

先定义类类型，再定义对象

• c++风格：将类的名字直接用作类型名

  类名 对象名列表;
  

• c风格：指定关键字class，struct，后面跟着类的名字

  class 类名 对象名列表;
      或
  struct 类名 对象名列表;
  

• 示例

  Point a, b; // c++特色定义对象
  class Point a, b; // 兼容c语言特色定义对象
  

定义类的同时定义对象

• 一般形式

  class 类名{
      成员列表
  } 对象名列表;
  

• 示例

  class Point{ // 类体
  public:...  // 公有的数据成员和成员函数
  private:... // 私有的数据成员和成员函数
  } one, two; // 对象列表
  

直接定义对象（不推荐）

说明：定义类型不分配空间，定义对象则分配空间

2. 动态对象的定义与使用

如何new一个动态对象

• 一般形式

  类名 * 对象指针变量;
  对象指针变量 = new 类名;
  

• 示例

  Point * p; // 定义指向Point对象的指针变量
  p = new Point; // 动态分配Point对象
  

说明：

1. new运算分配得到的是对象的起始地址，程序通过这个起始地址间接访问对象，因此需要先定义一个指向类的对象的指针变量
2. 执行new运算时，如果内存空间不足，则会返回一个0值指针，因此，只要检测返回值是否为0就可以判断动态分配对象是否成功，只有指针有效时才能使用对象指针

如何delete一个对象

• 当不再使用new运算动态分配的对象时，使用delete运算撤销

  delete p; // 撤销p所指向的Point对象
  

  说明：

  1. 释放p所指向的对象之后，不能再使用该对象
  2. new建立的动态对象不会被自动撤销，即使程序运行结束也是如此，必须认为使用delete撤销

3. 对象成员的引用

通过对象名和对象成员引用运算符（.）引用

• 访问对象中数据成员的一般形式

  对象名.成员名
  

• 访问对象中成员函数的一般形式

  对象名.成员函数(实参列表)
  

• 示例

  class Data{
  public:
      int data;
      void fun(int a, int b, int c);
  private:
      void add(int m) {data += m;}
      int x, y;
      ...
  }
  
  void caller1()
  {
      Data A, B; // 正确
      A.data = 100; // 正确
      A.fun(1, 3, 2); // 正确
      A.x = A.y = 1; // 错误，私有成员不能在类外部访问
      A.add(5); // 错误，私有成员不能在类外部访问
      B.data = 101; // 正确
      B.fun(4, 5, 6); // 正确
      
  }
  

通过指向对象的指针和指针成员引用运算符（->）引用

• 访问对象中数据成员的一般形式

  对象指针->成员名
  

• 访问对象中成员函数的一般形式

  对象指针->成员函数(实参列表)
  

• 示例

  class Data{
  public:
      int data;
      void fun(int a, int b, int c);
  private:
      void add(int m) {data += m;}
      int x, y;
      ...
  }
  
  void caller1()
  {
      Data A, p1, p; // 正确
      p1 = &A;
      p1->data = 100;
      p1->fun(1,2,3);
      p = new Data;
      p->data = 100;
      p->fun(1,2,3);
      delete p;   
  }
  

通过对象的引用变量和对象成员引用运算符（.）引用

• 访问对象中数据成员的一般形式

  对象引用变量名.成员名
  

• 访问对象中成员函数的一般形式

  对象引用变量名.成员函数(实参列表)
  

• 示例

  class Data{
  public:
      int data;
      void fun(int a, int b, int c);
  private:
      void add(int m) {data += m;}
      int x, y;
      ...
  }
  
  void caller1()
  {
      Data A, &r=A; // 
      r.data = 100; // 
      r.fun(1, 3, 2); //
  }
  

4. 对象的赋值

如果一个类定义了一个或多个对象，则同类对象之间可以相互赋值（“值”指的是对象中的数据成员），赋值的一般形式为

对象名1=对象名2

说明：

1. 对象的赋值只对其中的非静态成员赋值，而不对成员函数赋值
2. 如果对象的数据成员中包含了动态分配资源的指针，按上述赋值原理，赋值时只复制了指针值而没有复制指针所指向的内容

5. 对象、对象指针或对象引用作为函数的参数和返回值

函数的参数可以是对象、对象指针或对象引用

• 参数是对象
  • 形参是对象，则实参要求是相同类型的对象名，不能对类对象作任何隐式转换，此时形参是实参对象的副本
  • 采用这样的值传递方式会增加函数调用在空间、时间上的开销，当开销很大时不建议使用该方式
• 参数是对象指针
  • 形参是对象，实参要求是同类对象的指针，不能作任何隐式转换
  • 函数调用时， 无论类有多大，传递的参数是一个地址值，开销很小
  • 采用地址传递的方式，在函数中若按间接引用方式修改了形参对象的值，实际上就是修改实参对象的值，因此，使用对象指针作为函数参数可以向主调函数传回变化后的对象
• 参数是对象引用
  • 功能与对象指针相似
  • 实际上，函数形参对象是是实参对象的别名

#include<iostream>
using namespace;
void fun1(Data a, Data *p, Data &r)
{
    a.data = 100;
    p->data = 200;
    r.data = 300;
}

int main()
{
    Data A,B,C;
    func1(A, &B, C);
    return 0;
}

说明：如果不希望在函数中修改实参对象的值，函数形参可以作const限定

void fun2(Data a, const Data *p, const Data &r)
{
    a.data = 100;
    p->data = 200; // 错误
    r.data = 300; // 错误
}

• 不必对对象形参作const限定，如上述代码中的a，即使修改了a也不会影响实参对象

函数的返回值可以是对象、对象指针或对象引用

• 函数返回对象时，将其内存单元所有内容复制到一个临时对象中
• 函数返回对象指针或引用，本质上返回的是对象的地址而不是它的存储内容