曲径通幽论坛

标题: 包含（组合）关系 [打印本页]
作者: easy    时间: 2013-12-9 18:41
标题: 包含（组合）关系
比如有一个学生类，它包含了学生的姓名与一组考试成绩，“姓名” 和 “成绩” 与学生不是 is-a 关系，因为“学生”既不是姓名，也不是成绩；而是 has-a 关系，因为“学生”有姓名，也有考试分数。用来建立 has-a 关系的 C++ 技术是“组合”或称为“包含”，即创建一个包含其他类对象的类。比如可以将学生类 Student 类声明为：
class Student
{   
private:
    std::string name;   // name 是 string 对象
    std::valarray<double> scores;   // scores 是一个 valarray<double> 对象
    ... ...

name 和 scores 被声明为私有的， string 和 valarray<double> 类的公有接口可以访问与修改 name 和 scores 对象（比如 name.size() ，scores.sum()），但在类的外面不能这样做，而只能通过 Student 类的公有接口访问 name 和 scores 。

使用公有继承时，类可以继承接口，可能还有实现（基类的纯虚函数提供接口，但不提供实现）。获得接口是 is-a 关系的组成部分。而使用组合，类可以获得实现，但不能获得接口。不继承接口是 has-a 关系的组成部分。


对于 has-a 关系来说，类对象不能自动获得它所包含的对象的接口是一件好事。比如，string 类中重载的 + 运算符可以将两个字符串连接起来，然而这种方法对于 Student 来说没有什么意义，因为将两个“学生”串接起来没意义。尽管如此，但并不是说所有的接口对新类都没有意义。比如，可能希望使用 string 接口中的 operator<() 方法，以用来将对象按姓名进行排序，为此可以定义 Student::operator<() 成员函数，并在其内部使用 string::operator<() 来处理。

下面在 studentc.h 里声明了 Student 类：
[C++] 纯文本查看 复制代码
// studentc.h -- defining a Student class using containment

#ifndef STUDENTC_H_

#define STUDENTC_H_



#include <iostream>

#include <string>   

#include <valarray>

class Student

{   

private:

    typedef std::valarray<double> ArrayDb;

    std::string name;       // 包含对象

    ArrayDb scores;         // 包含对象



    // 输出 scores 的私有方法

    std::ostream & arr_out(std::ostream & os) const;



public:

    Student() : name("Null Student"), scores() {}



    explicit Student(const std::string & s) : name(s), scores() {}



    explicit Student(int n) : name("Nully"), scores(n) {}



    Student(const std::string & s, int n) : name(s), scores(n) {}



    Student(const std::string & s, const ArrayDb & a) : name(s), scores(a) {}



    Student(const char * str, const double * pd, int n) : name(str), scores(pd, n) {}



    ~Student() {}



    double Average() const;



    const std::string & Name() const;



    double & operator[](int i);



    double operator[](int i) const;



// 友元

    // 输入

    friend std::istream & operator>>(std::istream & is, Student & stu);  // 一单词



    friend std::istream & getline(std::istream & is, Student & stu);     // 一行



    // 输出

    friend std::ostream & operator<<(std::ostream & os,

                                     const Student & stu);

};



#endif

对于 explicit Student(int n) : name("Nully"), scores(n) {} 这个构造函数，它只有一个参数，对于这种情况，如果前面没有 explicit 作为限定的话，会存在从参数类型到类类型的隐式转换，这会带来问题，如对于下面的代码：
Student doh("Homer", 10);   // 设置 Homer 这个学生，并创建了可以存储 10 门课程成绩的数组
doh = 5;   //导致 Homer 这个学生被重置为 "Nully"，并且原来可以存储 10 门功课的数组现在只能存储 5 门功课

实际上，doh = 5; 原本是打算将某一门成绩的分数设置为 5 分，但是如上这么一搞，不但没达到设置的目的，反而破坏了原来的数据，正确的写法应为 doh[0] = 5; 。

因此，要用 explicit 来屏蔽隐式转换，在使用了 explicit 之后，编译器就会认为上述赋值运算符是错误的。

初始化被包含的对象成员
在构造函数 Student(const char * str, const double * pd, int n) : name(str), scores(pd, n) {} 中，初始化列表中使用的是成员名，而不是类名。初始化列表中的每一项都调用与之匹配的构造函数，即 name(str) 调用 string(const char *)，scores(pd, n) 调用的构造函数是 ArrayDb(const double *, int) 。

上面是使用了尘缘初始化列表的情况，那如果不使用初始化成员列表呢？那么 C++ 会在构建对象的其它部分之前，先构造继承对象的所有成员对象。因此，C++ 将使用成员对象所属类的默认构造函数。

对于初始化顺序需要注意：如果初始化列表中含有多个项目时，这些项目被初始化的顺序为它们被声明的顺序，而不是它们在初始化列表中的顺序。

如何使用包含对象的接口
被包含对象的接口不是共有的，但可以在类方法中使用它，比如：
  1. double Student::Average() const
  2. {
  3.     if (scores.size() > 0)
  4.         return scores.sum()/scores.size();  
  5.     else
  6.         return 0;
  7. }
复制代码
总之，Student 对象调用 Student 的方法（Average()），然后在其中使用被包含对象来调用它自己的方法。

studentc.h 对应的 cpp 文件：
[C++] 纯文本查看 复制代码
// studentc.cpp -- Student class using containment

#include "studentc.h"

using std::ostream;

using std::endl;

using std::istream;

using std::string;



//public 方法

double Student::Average() const

{

    if (scores.size() > 0)

        return scores.sum()/scores.size();  

    else

        return 0;

}



const string & Student::Name() const

{

    return name;

}



double & Student::operator[](int i)

{

    return scores;         // use valarray<double>::operator[]()

}



double Student::operator[](int i) const

{

    return scores;

}



// private 方法

ostream & Student::arr_out(ostream & os) const

{

    int i;

    int lim = scores.size();

    if (lim > 0)

    {

        for (i = 0; i < lim; i++)

        {

            os << scores << " ";

            if (i % 5 == 4)

                os << endl;

        }

        if (i % 5 != 0)

            os << endl;

    }

    else

        os << " empty array ";

    return os; 

}



// 友元



// use string version of operator>>()

istream & operator>>(istream & is, Student & stu)

{

    is >> stu.name;

    return is; 

}



// use string friend getline(ostream &, const string &)

istream & getline(istream & is, Student & stu)

{

    getline(is, stu.name);

    return is;

}



// use string version of operator<<()

ostream & operator<<(ostream & os, const Student & stu)

{

    os << "Scores for " << stu.name << ":\n";

    stu.arr_out(os);  // use private method for scores

    return os;

}


测试代码：
[C++] 纯文本查看 复制代码
// use_stuc.cpp -- using a composite class

// compile with studentc.cpp

#include <iostream>

#include "studentc.h"

using std::cin;

using std::cout;

using std::endl;



void set(Student & sa, int n);



const int pupils = 3;

const int quizzes = 5;



int main()

{

    Student ada[pupils] = 

        {Student(quizzes), Student(quizzes), Student(quizzes)};



    int i;

    for (i = 0; i < pupils; ++i)

        set(ada, quizzes);

    cout << "\nStudent List:\n";

    for (i = 0; i < pupils; ++i)

        cout << ada.Name() << endl;

    cout << "\nResults:";

    for (i = 0; i < pupils; ++i)

    {

        cout << endl << ada;

        cout << "average: " << ada.Average() << endl;

    }

    cout << "Done.\n";

    // cin.get();



    return 0;

}



void set(Student & sa, int n)

{

    cout << "Please enter the student's name: ";

    getline(cin, sa);

    cout << "Please enter " << n << " quiz scores:\n";

    for (int i = 0; i < n; i++)

        cin >> sa;

    while (cin.get() != '\n')

        continue; 

}





欢迎光临 曲径通幽论坛 (http://www.groad.net/bbs/) Powered by Discuz! X3.2