C++类 & 对象详解

淩亂°似流年 2022-05-04 03:30 244阅读 0赞

到目前为止，我们已经对 C++ 的类和对象有了基本的了解。下面的列表中还列出了其他一些 C++ 类和对象相关的概念，可以点击相应的链接进行学习。

<table> 
 <tbody> 
  <tr> 
   <th>概念</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-class-member-functions.html" rel="nofollow">类成员函数</a></td> 
   <td>类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-class-access-modifiers.html" rel="nofollow">类访问修饰符</a></td> 
   <td>类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-constructor-destructor.html" rel="nofollow">构造函数 &amp; 析构函数</a></td> 
   <td>类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-copy-constructor.html" rel="nofollow">C++ 拷贝构造函数</a></td> 
   <td>拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-friend-functions.html" rel="nofollow">C++ 友元函数</a></td> 
   <td><strong>友元函数</strong>可以访问类的 private 和 protected 成员。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-inline-functions.html" rel="nofollow">C++ 内联函数</a></td> 
   <td>通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-this-pointer.html" rel="nofollow">C++ 中的 this 指针</a></td> 
   <td>每个对象都有一个特殊的指针 <strong>this</strong>，它指向对象本身。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-pointer-to-class.html" rel="nofollow">C++ 中指向类的指针</a></td> 
   <td>指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-static-members.html" rel="nofollow">C++ 类的静态成员</a></td> 
   <td>类的数据成员和函数成员都可以被声明为静态的。</td> 
  </tr> 
 </tbody> 
</table>

# C++ 类成员函数 #

[![C++ 类 & 对象][C_ _ _] C++ 类 & 对象][C_ _ _ _C_ _ _ C_ _ _]

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

让我们看看之前定义的类 Box，现在我们要使用成员函数来访问类的成员，而不是直接访问这些类的成员：

class Box
    {
       public:
          double length;         // 长度
          double breadth;        // 宽度
          double height;         // 高度
          double getVolume(void);// 返回体积
    };

成员函数可以定义在类定义内部，或者单独使用**范围解析运算符 ::** 来定义。在类定义中定义的成员函数把函数声明为**内联**的，即便没有使用 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();  // 调用该对象的成员函数

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

#include <iostream>
     
    using namespace std;
     
    class Box
    {
       public:
          double length;         // 长度
          double breadth;        // 宽度
          double height;         // 高度
     
          // 成员函数声明
          double getVolume(void);
          void setLength( double len );
          void setBreadth( double bre );
          void setHeight( double hei );
    };
     
    // 成员函数定义
    double Box::getVolume(void)
    {
        return length * breadth * height;
    }
     
    void Box::setLength( double len )
    {
        length = len;
    }
     
    void Box::setBreadth( double bre )
    {
        breadth = bre;
    }
     
    void Box::setHeight( double hei )
    {
        height = hei;
    }
     
    // 程序的主函数
    int main( )
    {
       Box Box1;                // 声明 Box1，类型为 Box
       Box Box2;                // 声明 Box2，类型为 Box
       double volume = 0.0;     // 用于存储体积
     
       // box 1 详述
       Box1.setLength(6.0); 
       Box1.setBreadth(7.0); 
       Box1.setHeight(5.0);
     
       // box 2 详述
       Box2.setLength(12.0); 
       Box2.setBreadth(13.0); 
       Box2.setHeight(10.0);
     
       // box 1 的体积
       volume = Box1.getVolume();
       cout << "Box1 的体积：" << volume <<endl;
     
       // box 2 的体积
       volume = Box2.getVolume();
       cout << "Box2 的体积：" << volume <<endl;
       return 0;
    }

当上面的代码被编译和执行时，它会产生下列结果：

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

# C++ 类访问修饰符 #

[![C++ 类 & 对象][C_ _ _] C++ 类 & 对象][C_ _ _ _C_ _ _ C_ _ _]

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

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

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

## 公有（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;
    }

当上面的代码被编译和执行时，它会产生下列结果：

Length of line : 6
    Length of line : 10

## 私有（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;
    }

当上面的代码被编译和执行时，它会产生下列结果：

Length of box : 10
    Width of box : 10

## 保护（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;
    }

当上面的代码被编译和执行时，它会产生下列结果：

Width of box : 5

## 继承中的特点 ##

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

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

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

*  1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；
 *  2.protected 成员可以被派生类访问。

### public 继承 ###

#include<iostream>
    #include<assert.h>
    using namespace std;
     
    class A{
    public:
      int a;
      A(){
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
      }
      void fun(){
        cout << a << endl;    //正确
        cout << a1 << endl;   //正确
        cout << a2 << endl;   //正确
        cout << a3 << endl;   //正确
      }
    public:
      int a1;
    protected:
      int a2;
    private:
      int a3;
    };
    class B : public A{
    public:
      int a;
      B(int i){
        A();
        a = i;
      }
      void fun(){
        cout << a << endl;       //正确，public成员
        cout << a1 << endl;       //正确，基类的public成员，在派生类中仍是public成员。
        cout << a2 << endl;       //正确，基类的protected成员，在派生类中仍是protected可以被派生类访问。
        cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。
      }
    };
    int main(){
      B b(10);
      cout << b.a << endl;
      cout << b.a1 << endl;   //正确
      cout << b.a2 << endl;   //错误，类外不能访问protected成员
      cout << b.a3 << endl;   //错误，类外不能访问private成员
      system("pause");
      return 0;
    }

protected 继承

#include<iostream>
    #include<assert.h>
    using namespace std;
    class A{
    public:
      int a;
      A(){
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
      }
      void fun(){
        cout << a << endl;    //正确
        cout << a1 << endl;   //正确
        cout << a2 << endl;   //正确
        cout << a3 << endl;   //正确
      }
    public:
      int a1;
    protected:
      int a2;
    private:
      int a3;
    };
    class B : protected A{
    public:
      int a;
      B(int i){
        A();
        a = i;
      }
      void fun(){
        cout << a << endl;       //正确，public成员。
        cout << a1 << endl;       //正确，基类的public成员，在派生类中变成了protected，可以被派生类访问。
        cout << a2 << endl;       //正确，基类的protected成员，在派生类中还是protected，可以被派生类访问。
        cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。
      }
    };
    int main(){
      B b(10);
      cout << b.a << endl;       //正确。public成员
      cout << b.a1 << endl;      //错误，protected成员不能在类外访问。
      cout << b.a2 << endl;      //错误，protected成员不能在类外访问。
      cout << b.a3 << endl;      //错误，private成员不能在类外访问。
      system("pause");
      return 0;
    }

private 继承

#include<iostream>
    #include<assert.h>
    using namespace std;
    class A{
    public:
      int a;
      A(){
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
      }
      void fun(){
        cout << a << endl;    //正确
        cout << a1 << endl;   //正确
        cout << a2 << endl;   //正确
        cout << a3 << endl;   //正确
      }
    public:
      int a1;
    protected:
      int a2;
    private:
      int a3;
    };
    class B : private A{
    public:
      int a;
      B(int i){
        A();
        a = i;
      }
      void fun(){
        cout << a << endl;       //正确，public成员。
        cout << a1 << endl;       //正确，基类public成员,在派生类中变成了private,可以被派生类访问。
        cout << a2 << endl;       //正确，基类的protected成员，在派生类中变成了private,可以被派生类访问。
        cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。
      }
    };
    int main(){
      B b(10);
      cout << b.a << endl;       //正确。public成员
      cout << b.a1 << endl;      //错误，private成员不能在类外访问。
      cout << b.a2 << endl;      //错误, private成员不能在类外访问。
      cout << b.a3 << endl;      //错误，private成员不能在类外访问。
      system("pause");
      return 0;
    }

**总结一下三种继承方式：**

<table> 
 <thead> 
  <tr> 
   <th>继承方式</th> 
   <th>基类的public成员</th> 
   <th>基类的protected成员</th> 
   <th>基类的private成员</th> 
   <th>继承引起的访问控制关系变化概括</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public继承</td> 
   <td>仍为public成员</td> 
   <td>仍为protected成员</td> 
   <td>不可见</td> 
   <td>基类的非私有长远在子类的访问属性不变</td> 
  </tr> 
  <tr> 
   <td>protected继承</td> 
   <td>变为protected成员</td> 
   <td>变为protected成员</td> 
   <td>不可见</td> 
   <td>基类的非私有成员都为子类的保护成员</td> 
  </tr> 
  <tr> 
   <td>private继承</td> 
   <td>变为private成员</td> 
   <td>变为private成员</td> 
   <td>不可见</td> 
   <td>基类中的非私有成员都称为子类的私有成员</td> 
  </tr> 
 </tbody> 
</table>

# C++ 类构造函数 & 析构函数 #

[![C++ 类 & 对象][C_ _ _] C++ 类 & 对象][C_ _ _ _C_ _ _ C_ _ _]

## 类的构造函数 ##

类的**构造函数**是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 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;
    }

当上面的代码被编译和执行时，它会产生下列结果：

Object is being created
    Length of line : 6

## 带参数的构造函数 ##

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

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

## 类的析构函数 ##

类的**析构函数**是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

下面的实例有助于更好地理解析构函数的概念：

#include <iostream>
     
    using namespace std;
     
    class Line
    {
       public:
          void setLength( double len );
          double getLength( void );
          Line();   // 这是构造函数声明
          ~Line();  // 这是析构函数声明
     
       private:
          double length;
    };
     
    // 成员函数定义，包括构造函数
    Line::Line(void)
    {
        cout << "Object is being created" << endl;
    }
    Line::~Line(void)
    {
        cout << "Object is being deleted" << 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
    Object is being deleted

# C++ 拷贝构造函数 #

[![C++ 类 & 对象][C_ _ _] C++ 类 & 对象][C_ _ _ _C_ _ _ 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(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;
    }

当上面的代码被编译和执行时，它会产生下列结果：

调用构造函数
    调用拷贝构造函数并为指针 ptr 分配内存
    line 大小 : 10
    释放内存
    释放内存

下面的实例对上面的实例稍作修改，通过使用已有的同类型的对象来初始化新创建的对象：

#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 line1(10);
     
       Line line2 = line1; // 这里也调用了拷贝构造函数
     
       display(line1);
       display(line2);
     
       return 0;
    }

当上面的代码被编译和执行时，它会产生下列结果：

调用构造函数
    调用拷贝构造函数并为指针 ptr 分配内存
    调用拷贝构造函数并为指针 ptr 分配内存
    line 大小 : 10
    释放内存
    调用拷贝构造函数并为指针 ptr 分配内存
    line 大小 : 10
    释放内存
    释放内存
    释放内存

# C++ 友元函数 #

[![C++ 类 & 对象][C_ _ _] C++ 类 & 对象][C_ _ _ _C_ _ _ C_ _ _]

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。

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

class Box
    {
       double width;
    public:
       double length;
       friend void printWidth( Box box );
       void setWidth( double wid );
    };

声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元，需要在类 ClassOne 的定义中放置如下声明：

friend class ClassTwo;

请看下面的程序：

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

当上面的代码被编译和执行时，它会产生下列结果：

Width of box : 10

# C++ 内联函数 #

[![C++ 类 & 对象][C_ _ _] C++ 类 & 对象][C_ _ _ _C_ _ _ C_ _ _]

C++ **内联函数**是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。

对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。

如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 **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;
    }

当上面的代码被编译和执行时，它会产生下列结果：

Max (20,10): 20
    Max (0,200): 200
    Max (100,1010): 1010

# C++ this 指针 #

[![C++ 类 & 对象][C_ _ _] C++ 类 & 对象][C_ _ _ _C_ _ _ C_ _ _]

在 C++ 中，每一个对象都能通过 **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 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;
    }

当上面的代码被编译和执行时，它会产生下列结果：

Constructor called.
    Constructor called.
    Box2 is equal to or larger than Box1

[C_ _ _]: http://www.runoob.com/images/up.gif
[C_ _ _ _C_ _ _ C_ _ _]: /images/20220504/385f3ec58ccf4adf9e04cc799b82aae5.png