第14章 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; // contained object
      ArrayDb scores; // contained object
     // private method for scores output
     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;

   // friends
   // input
   friend std::istream & operator>>(std::istream & is,
   Student & stu); // 1 word
   friend std::istream & getline(std::istream & is,
   Student & stu); // 1 line
 
   // output
   friend std::ostream & operator<<(std::ostream & os,
   const Student & stu);
};

//public methods
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[i]; // use valarray<double>::operator[]()
}

double Student::operator[](int i) const
{
        return scores[i];
}

// private method
ostream & Student::arr_out(ostream & os) const
{
        int i;
        int lim = scores.size();
        if (lim > 0)
        {
               for (i = 0; i < lim; i++)
               {
                    os << scores[i] << " ";
                    if (i % 5 == 4)
                            os << endl;
               }
         if (i % 5 != 0)
               os << endl;
        }
        else
              os << " empty array ";
              return os;
}

// friends

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

#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[i], quizzes);
     cout << "\nStudent List:\n";
     for (i = 0; i < pupils; ++i)
         cout << ada[i].Name() << endl;
     cout << "\nResults:";
     for (i = 0; i < pupils; ++i)
     {
        cout << endl << ada[i];
        cout << "average: " << ada[i].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[i];
    while (cin.get() != '\n')
        continue;
}

重命名

构造函数

成员函数

友元函数

建立对象数组，注意，ada[][] 表示的是成绩。

组合：
Student(const std::string & s, const ArrayDb & a)
     : name(s), scores(a) {}
私有继承： 
Student(const std::string & s, int n) 
      : std::string(s), ArrayDb(n) {}

说明

1
（调用基类的方法）

2
（返回基类的私有数据）

组合关系

私有继承

说明

为什么不能在派生类中？

class SingerWaiter : public Singer , public Waiter { ... }

有多少个worker?

哪个方法?

代码

说明

SingerWaiter（const Worker & wk , int p=0 , int v = Singer::other）
:Waiter( wk,p),Singer(wk,v){}//flawed

• 不起作用，因为将通过两种不同的途径（worker 和 singer）将wk传递给Worker对象。
  
• C++基类为虚时，禁止信息通过中间类自动传递给基类，所以上述构造函数将初始化
  

成员panache 和 voice ,但wk参数中的信息不会传递给子对象waiter.//只有构造函数才是这样？

• 但又必须派生对象之前构造基类对象组件。
  

• 对虚基类，除非只需使用该虚基类的默认构造函数，这种用法
  

（直接调用虚基类的构造函数，即使不是直接基类）是合法的也是必须的。

• 对非虚基类，这种用法是不正确的。
  

作用域解析运算

在SingerWaiter中
重新定义Show( )
//指明使用哪个版本

使用虚基类时，如果某个名称优先于其他所有名称，名称
不会产生二义性。

虚二义性规则与访问规则无关

要以template<..>开头，可以把class 看做是变量的类型名，该变量接收类型作为其值.

class可用typename 代替

Type可以使用自己的泛型名代替，一般用T,Type

对于Stack来说，意味着应将声明中所用typedef标识符Item
替换成Type

//改为
template<class Type>
bool Stack<Type>::push(const Type & item)
{
.....
}

http://blog.csdn.net/acs713/article/details/12508049

特殊性

构造函数方法（方法一）使用的是通过new 和delete管理的堆内存，表达式参数方法使用
的是为自动变量维护的内存栈，执行速度快

每种数组大小都声明自己的模板

构造函数方法（方法2）更通用，它可以将一种尺寸的数组赋给另一种尺寸的数组，
也允许改变数组的大小。

!!!注意写法

C++98要求至少要用一个空白字符将两个>分开以区分>>,
C++11不要求这样做

twodee是包含10个元素的数组，其中每个元素都是一个包含
5个int元素的数组。

等价于int twodee[10][5]

可直接用twodee[i][j]表示...

结果

编译器在需要对象之前，不会生成类的隐式实例化

tempalate<typename T>
class SortedArray{
....
};

类型参数之1指定具体类型

例如，模板

template<class T1>
class Pair<T1,int>{
....
}
//部分实例化

template<>
class Pair<int ,int>{
...
};

多个模板可选择时，编译器将使用具体化程度最高的模板
Pair<double,double>p1;//use general Pair template;
Pair<double,int>//use Pair<T1,int>;
Pair<int,int>//use Pair<int,int>;

为指针提供特殊版本来部分具体化现有模板

template<class T>
class Feeb{ .... };

template<class T*>
class Feeb{ ... };

Feeb<char> fb1;
Feeb<char *> fb2; // use Feeb T*;

格式

说明

格式

说明

格式

说明

template<typename T> 是类型，Thing是参数
//
template<typename T>——typename/class
Thing                            ——Type/T

main中，若有Crab<king> legs;
则king一定要是类模板；与Thing匹配，即King要有以下定义
template<typename T>
class King{ ... };

格式

问题

第4点的应用

格式

说明

template<typename T> void counts()；
template<typename T> void report( T & hf )；

说明

template<typename TT>
class HasFriendT
{
....
   friend void counts<TT>( );
   friend void report<>(HasFriendT<TT> & );

说明

template<typename T> 
void counts(){
....
}

template<typename T>
void report( T & hf ){
  ......
}