Chapter 14 C++中的代码重用

#include <iostream>
#include <valarray> // 包含 valarray 头文件
#include <vector>   // 用于初始化示例

int main() {
    std::vector<double> data = {1.1, 2.2, 3.3, 4.4};
    std::valarray<double> v1(data.data(), data.size()); // 从 double 数组创建 valarray
    std::valarray<double> v2 = {10.0, 10.0, 10.0, 10.0}; // 使用初始化列表 (C++11)
    std::valarray<double> v_sum(4); // 创建一个大小为 4 的 valarray

    v_sum = v1 + v2; // 逐元素相加: v_sum = {11.1, 12.2, 13.3, 14.4}

    std::cout << "Sum of elements in v1: " << v1.sum() << std::endl; // 输出 11
    std::cout << "Size of v1: " << v1.size() << std::endl;         // 输出 4
    std::cout << "Element at index 1 in v_sum: " << v_sum[1] << std::endl; // 输出 12.2

    v1 *= 2.0; // 所有元素乘以 2: v1 = {2.2, 4.4, 6.6, 8.8}
    for(double x : v1) { // C++11 范围 for 循环
        std::cout << x << " ";
    }
    std::cout << std::endl;

    return 0;
}

#ifndef STUDENTC_H_
#define STUDENTC_H_

#include <iostream>
#include <string>
#include <valarray> // 包含 valarray

class Student {
private:
    // 使用包含（组合）: Student "has-a" string and "has-a" valarray
    std::string name;               // 姓名
    std::valarray<double> scores;   // 分数 (使用 valarray)

    // 私有方法，用于输出分数
    std::ostream & arr_out(std::ostream & os) const;

public:
    // 构造函数
    Student() : name("Null Student"), scores() {} // 默认构造函数
    // 使用 string 和 valarray 初始化
    Student(const std::string & s, const std::valarray<double> & a)
        : name(s), scores(a) {}
    // 使用 string 和 C 风格数组初始化
    Student(const std::string & s, const double * pd, int n)
        : name(s), scores(pd, n) {} // valarray 构造函数接受 (指针, 数量)
    // 使用 C 风格字符串和 C 风格数组初始化
    Student(const char * str, const double * pd, int n)
        : name(str), scores(pd, n) {} // string 和 valarray 构造函数处理转换

    ~Student() {} // 析构函数 (默认即可，因为 string 和 valarray 会自己管理资源)

    // 访问器
    double Average() const; // 计算平均分
    const std::string & Name() const; // 获取姓名 (返回 const 引用避免复制)
    double operator[](int i) const; // 获取第 i 门课分数 (const 版本)
    double & operator[](int i);     // 获取/设置第 i 门课分数 (非 const 版本)

    // 友元函数 - 用于输入输出
    // input
    friend std::istream & operator>>(std::istream & is, Student & stu); // 读取姓名
    friend std::istream & getline(std::istream & is, Student & stu);   // 读取姓名 (整行)
    // output
    friend std::ostream & operator<<(std::ostream & os, const Student & stu);
};

#endif // STUDENTC_H_

#include "studentc.h"
using std::ostream;
using std::endl;
using std::istream;
using std::string;

// 公有方法实现
double Student::Average() const {
    if (scores.size() > 0)
        return scores.sum() / scores.size(); // 使用 valarray 的 sum() 和 size()
    else
        return 0;
}

const string & Student::Name() const {
    return name;
}

// 使用 [] 访问分数
double Student::operator[](int i) const {
    return scores[i]; // 调用 valarray 的 operator[]
}

double & Student::operator[](int i) {
    return scores[i]; // 调用 valarray 的 operator[]
}

// 私有方法实现
// 输出分数数组
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) // 每 5 个换行
                os << endl;
        }
        if (i % 5 != 0)
            os << endl;
    } else
        os << " empty array ";
    return os;
}

// 友元函数实现
// 使用 >> 读取姓名
istream & operator>>(istream & is, Student & stu) {
    is >> stu.name; // 调用 string 的 operator>>
    return is;
}

// 使用 getline 读取姓名 (整行)
istream & getline(istream & is, Student & stu) {
    getline(is, stu.name); // 调用 string 的 getline
    return is;
}

// 使用 << 输出学生信息
ostream & operator<<(ostream & os, const Student & stu) {
    os << "Scores for " << stu.name << ":\n";
    stu.arr_out(os); // 使用私有方法输出分数
    return os;
}

#include <iostream>
#include "studentc.h" // 包含 Student 类定义
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 对象数组
        Student(quizzes), Student(quizzes), Student(quizzes) // 假设有 Student(int n) 构造函数
    };

    // 假设 studentc.h/cpp 已修改，添加构造函数 Student(int n)
    // Student::Student(int n) : name("Nully"), scores(n) {} // 示例构造函数

    // 如果没有 Student(int n)，则需要这样创建：
    // double sample_scores[quizzes] = {0.0}; // 示例分数
    // Student ada[pupils] = {
    //     Student("Default1", sample_scores, quizzes),
    //     Student("Default2", sample_scores, quizzes),
    //     Student("Default3", sample_scores, quizzes)
    // };
    // 为了编译通过，我们假设 Student(int n) 存在

    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]; // 输出完整信息 (调用 operator<<)
        cout << "average: " << ada[i].Average() << endl; // 输出平均分
    }

    cout << "Done.\n";
    return 0;
}

// 函数：设置学生姓名和分数
void set(Student & sa, int n) {
    cout << "Please enter the student's name: ";
    getline(cin, sa); // 使用友元 getline 读取姓名
    cout << "Please enter " << n << " quiz scores:\n";
    for (int i = 0; i < n; i++)
        cin >> sa[i]; // 使用 operator[] 设置分数
    while (cin.get() != '\n') // 清除输入缓冲区
        continue;
}

// --- 需要修改 studentc.h/cpp 添加 Student(int n) 构造函数 ---
/*
// studentc.h 添加:
    explicit Student(int n) : name("Nully"), scores(n) {} // explicit 防止意外转换

// studentc.cpp 不需要额外添加，因为初始化列表已完成工作
*/

class DerivedClassName : private BaseClassName {
    // ... 派生类成员 ...
};

#ifndef STUDENTI_H_
#define STUDENTI_H_

#include <iostream>
#include <valarray>
#include <string>

// 使用私有继承的 Student 类
class Student : private std::string, private std::valarray<double> {
private:
    // 私有辅助函数，用于输出分数
    // 注意：现在可以直接访问 valarray 的方法，但它们是私有的
    std::ostream & arr_out(std::ostream & os) const;

public:
    // 构造函数
    // 需要显式调用基类的构造函数
    Student() : std::string("Null Student"), std::valarray<double>() {}
    explicit Student(const std::string & s)
        : std::string(s), std::valarray<double>() {}
    explicit Student(int n) : std::string("Nully"), std::valarray<double>(n) {}
    Student(const std::string & s, int n)
        : std::string(s), std::valarray<double>(n) {}
    Student(const std::string & s, const std::valarray<double> & a)
        : std::string(s), std::valarray<double>(a) {}
    Student(const char * str, const double * pd, int n)
        : std::string(str), std::valarray<double>(pd, n) {}

    ~Student() {} // 析构函数 (默认即可)

    // 访问器 - 需要自己提供接口，不能直接用基类的
    double Average() const;
    double & operator[](int i);
    double operator[](int i) const;
    const std::string & Name() 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 // STUDENTI_H_

#include "studenti.h"
using std::ostream;
using std::endl;
using std::istream;
using std::string;
using std::valarray;

// 公有方法实现
double Student::Average() const {
    // 可以访问 valarray 的 public 方法 (在 Student 内部是 private)
    if (valarray<double>::size() > 0)
        return valarray<double>::sum() / valarray<double>::size();
    else
        return 0;
}

const string & Student::Name() const {
    // 可以访问 string 的 public 方法 (在 Student 内部是 private)
    // 需要强制类型转换回基类类型来调用
    return (const string &) *this; // 将 *this 转换为对基类 string 的引用
}

// 使用 [] 访问分数
double & Student::operator[](int i) {
    // 可以访问 valarray 的 public 方法 (在 Student 内部是 private)
    // 需要强制类型转换回基类类型来调用
    return valarray<double>::operator[](i); // 或者 ((valarray<double> &)*this)[i];
}

double Student::operator[](int i) const {
    return valarray<double>::operator[](i); // 或者 ((const valarray<double> &)*this)[i];
}

// 私有方法实现
ostream & Student::arr_out(ostream & os) const {
    int i;
    int lim = valarray<double>::size();
    if (lim > 0) {
        for (i = 0; i < lim; i++) {
            os << operator[](i) << " "; // 使用 Student::operator[]
            if (i % 5 == 4)
                os << endl;
        }
        if (i % 5 != 0)
            os << endl;
    } else
        os << " empty array ";
    return os;
}

// 友元函数实现
// 友元可以访问派生类的私有成员，包括继承来的私有成员（原基类的公有/保护成员）
istream & operator>>(istream & is, Student & stu) {
    // 直接访问继承来的 string 部分 (现在是 stu 的私有部分)
    is >> (string &)stu; // 需要类型转换
    return is;
}

istream & getline(istream & is, Student & stu) {
    getline(is, (string &)stu); // 需要类型转换
    return is;
}

ostream & operator<<(ostream & os, const Student & stu) {
    os << "Scores for " << (const string &) stu << ":\n"; // 需要类型转换
    stu.arr_out(os); // 调用私有辅助函数
    return os;
}

#include "studenti.h" // 使用私有继承版本
#include <iostream>
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; // 调用 Student 提供的 Name() 接口

    cout << "\nResults:";
    for (i = 0; i < pupils; ++i) {
        cout << endl << ada[i]; // 调用 Student 的 operator<<
        cout << "average: " << ada[i].Average() << endl; // 调用 Student 的 Average()
    }

    // 无法直接访问基类方法
    // cout << ada[0].size(); // 错误！valarray::size() 在 Student 中是 private
    // cout << ada[0].length(); // 错误！string::length() 在 Student 中是 private

    // 无法将派生类指针隐式转换为基类指针
    // string * pstr = &ada[0]; // 错误！
    // valarray<double> * pva = &ada[0]; // 错误！

    cout << "Done.\n";
    return 0;
}

// set 函数定义 (同之前)
void set(Student & sa, int n) {
    cout << "Please enter the student's name: ";
    getline(cin, sa); // 使用友元 getline
    cout << "Please enter " << n << " quiz scores:\n";
    for (int i = 0; i < n; i++)
        cin >> sa[i]; // 使用 Student::operator[]
    while (cin.get() != '\n')
        continue;
}

class DerivedClassName : protected BaseClassName {
    // ...
};

using BaseClassName::MemberName;

// studenti.h (修改后)
class Student : private std::string, private std::valarray<double> {
private:
    std::ostream & arr_out(std::ostream & os) const;
public:
    // ... 构造函数 ...
    ~Student() {}

    // 使用 using 声明将基类的部分成员暴露为 public
    using std::valarray<double>::size; // 使 valarray::size() 成为 Student 的 public 成员
    using std::valarray<double>::operator[]; // 使 valarray::operator[] 成为 Student 的 public 成员

    // 仍然需要提供自己的接口，或者暴露更多基类成员
    double Average() const;
    const std::string & Name() const;
    // operator[] 现在通过 using 声明暴露了，可以移除 Student 自己的版本 (如果签名匹配)

    // ... 友元 ...
};

// studenti.cpp (修改后)
double Student::Average() const {
    // 现在可以直接调用 size() 和 sum() (如果 sum 也 using 了)
    if (size() > 0) // 直接调用继承来的 size()
        // return sum() / size(); // 假设 sum() 也 using 了
        return std::valarray<double>::sum() / size(); // 或者仍然显式调用
    else
        return 0;
}
// operator[] 的实现可以移除了，因为 using 声明提供了它

// ... 其他实现可能也需要调整 ...

class DerivedClassName : accessSpecifier1 BaseClass1, accessSpecifier2 BaseClass2, ... {
    // ... 派生类成员 ...
};

class Worker { /* ... id, name ... */ };
class Singer { /* ... voice range, sing() ... */ };
class Waiter { /* ... panache, serve() ... */ };

// SingingWaiter 继承自 Singer 和 Waiter
class SingingWaiter : public Singer, public Waiter {
    // ... SingingWaiter 特有的成员 ...
};

class Worker {
public:
    long id;
    std::string fullname;
    virtual ~Worker() {}
    virtual void Show() const { /* ... show id, name ... */ }
    // ... other methods ...
};

class Waiter : public Worker {
public:
    int panache;
    virtual void Show() const override { /* ... show worker info + panache ... */ }
    // ... other methods ...
};

class Singer : public Worker {
public:
    enum {other, alto, contralto, soprano, bass, baritone, tenor};
    static const int Vtypes = 7;
    int voice;
    virtual void Show() const override { /* ... show worker info + voice ... */ }
    // ... other methods ...
};

// SingingWaiter 继承自 Waiter 和 Singer，两者都继承自 Worker
class SingingWaiter : public Waiter, public Singer {
public:
    virtual void Show() const override { /* ... show all info ... */ }
    // ... other methods ...
};

class Waiter {
public:
    void Talent() const { std::cout << "Serves with style.\n"; }
    // ...
};
class Singer {
public:
    void Talent() const { std::cout << "Sings beautifully.\n"; }
    // ...
};
class SingingWaiter : public Waiter, public Singer {
    // ...
};

SingingWaiter sw;
// sw.Talent(); // 错误！歧义：Waiter::Talent() 还是 Singer::Talent()？

sw.Waiter::Talent(); // 调用 Waiter 版本的 Talent()
sw.Singer::Talent(); // 调用 Singer 版本的 Talent()

template <typename T1, typename T2, ...> // 或者 template <class T1, class T2, ...>
class ClassName {
    // 类定义，可以使用模板参数 T1, T2 等作为类型
private:
    T1 member1;
    T2 member2;
    // ...
public:
    ClassName(const T1 & val1, const T2 & val2);
    T1 getMember1() const;
    // ...
};

// 成员函数的定义也需要模板前缀
template <typename T1, typename T2, ...>
ClassName<T1, T2, ...>::ClassName(const T1 & val1, const T2 & val2)
    : member1(val1), member2(val2) {
    // ...
}

template <typename T1, typename T2, ...>
T1 ClassName<T1, T2, ...>::getMember1() const {
    return member1;
}

// stacktp.h -- 一个简单的栈模板类定义
#ifndef STACKTP_H_
#define STACKTP_H_

template <typename T> // 或者 template <class T>
class Stack {
private:
    enum { MAX = 10 }; // 栈的最大容量 (非类型参数可以改进)
    T items[MAX];      // 存储栈元素的数组，类型为 T
    int top;           // 栈顶索引
public:
    Stack();
    bool isempty() const;
    bool isfull() const;
    // push() returns false if stack already is full, true otherwise
    bool push(const T & item); // 参数类型为 T
    // pop() returns false if stack already is empty, true otherwise
    bool pop(T & item);        // 参数类型为 T (通过引用返回弹出的元素)
};

// 成员函数实现 (通常也放在头文件中)
template <typename T>
Stack<T>::Stack() : top(0) { // 初始化栈顶
}

template <typename T>
bool Stack<T>::isempty() const {
    return top == 0;
}

template <typename T>
bool Stack<T>::isfull() const {
    return top == MAX;
}

template <typename T>
bool Stack<T>::push(const T & item) {
    if (top < MAX) {
        items[top++] = item; // 使用类型 T 的赋值操作
        return true;
    } else {
        return false;
    }
}

template <typename T>
bool Stack<T>::pop(T & item) {
    if (top > 0) {
        item = items[--top]; // 使用类型 T 的赋值操作
        return true;
    } else {
        return false;
    }
}

#endif // STACKTP_H_

// stack_user.cpp -- 使用 Stack 模板类
#include <iostream>
#include <string>
#include <cctype> // for isalpha, etc. (假设用于处理输入)
#include "stacktp.h" // 包含模板定义

int main() {
    // 实例化一个处理 int 的栈
    Stack<int> intStack; // intStack 是一个 Stack<int> 类型的对象
    int i = 0;
    std::cout << "Pushing integers onto intStack:\n";
    while (!intStack.isfull() && i < 5) {
        intStack.push(i++);
        std::cout << i-1 << " pushed. ";
    }
    std::cout << std::endl;

    int tempInt;
    std::cout << "Popping integers from intStack:\n";
    while (intStack.pop(tempInt)) {
        std::cout << tempInt << " popped. ";
    }
    std::cout << std::endl;

    // 实例化一个处理 string 的栈
    Stack<std::string> stringStack; // stringStack 是一个 Stack<std::string> 对象
    std::string items[] = {"apple", "banana", "cherry"};
    std::cout << "Pushing strings onto stringStack:\n";
    for (const auto& s : items) {
        if (stringStack.push(s)) {
            std::cout << "\"" << s << "\" pushed. ";
        } else {
            std::cout << "Stack full, cannot push \"" << s << "\".\n";
            break;
        }
    }
    std::cout << std::endl;

    std::string tempString;
    std::cout << "Popping strings from stringStack:\n";
    while (stringStack.pop(tempString)) {
        std::cout << "\"" << tempString << "\" popped. ";
    }
    std::cout << std::endl;

    return 0;
}

template <typename T, int N> // T 是类型参数，N 是非类型参数 (int 类型)
class ArrayTP {
private:
    T ar[N]; // 数组大小由模板参数 N 决定
    // ...
public:
    T & operator[](int i);
    // ...
};

// arraytp.h -- 模板类 ArrayTP
#ifndef ARRAYTP_H_
#define ARRAYTP_H_

#include <iostream>
#include <cstdlib> // for exit()

template <typename T, int n> // n 是非类型参数
class ArrayTP {
private:
    T ar[n]; // 数组大小为 n
public:
    ArrayTP() {};
    explicit ArrayTP(const T & v);
    virtual T & operator[](int i);
    virtual T operator[](int i) const;
};

template <typename T, int n>
ArrayTP<T, n>::ArrayTP(const T & v) {
    for (int i = 0; i < n; i++)
        ar[i] = v;
}

template <typename T, int n>
T & ArrayTP<T, n>::operator[](int i) {
    if (i < 0 || i >= n) {
        std::cerr << "Error in array limits: " << i
                  << " is out of range\n";
        std::exit(EXIT_FAILURE);
    }
    return ar[i];
}

template <typename T, int n>
T ArrayTP<T, n>::operator[](int i) const {
    if (i < 0 || i >= n) {
        std::cerr << "Error in array limits: " << i
                  << " is out of range\n";
        std::exit(EXIT_FAILURE);
    }
    return ar[i];
}

#endif // ARRAYTP_H_

// 使用 ArrayTP
#include "arraytp.h" // 包含模板定义

int main() {
    // 实例化一个包含 10 个 int 的数组
    ArrayTP<int, 10> sums;
    // 实例化一个包含 10 个 double 的数组
    ArrayTP<double, 10> aves;
    // 实例化一个包含 5 个指向 double 的指针的数组
    ArrayTP< ArrayTP<int, 5>, 10 > twodee; // 模板嵌套：10x5 的 int 数组

    int i, j;
    for (i = 0; i < 10; i++) {
        sums[i] = 0;
        for (j = 0; j < 5; j++) {
            twodee[i][j] = (i + 1) * (j + 1);
            sums[i] += twodee[i][j];
        }
        aves[i] = (double) sums[i] / 5;
    }

    for (i = 0; i < 10; i++) {
        std::cout.width(2);
        std::cout << i << ": ";
        std::cout.width(3);
        std::cout << sums[i] << " = average " << aves[i] << std::endl;
    }

    // ArrayTP<double, 0> zero_size; // 错误或无意义，取决于编译器和实现

    return 0;
}

template<typename T>
class SmartPtr {
private:
    T* ptr;
public:
    explicit SmartPtr(T* p = nullptr) : ptr(p) {}
    ~SmartPtr() { delete ptr; }

    // 模板成员：模板复制构造函数
    template<typename U>
    SmartPtr(const SmartPtr<U>& other) {
        // 允许从 SmartPtr<U> 构造 SmartPtr<T>
        // 通常需要 U* 能够隐式转换为 T* (例如 U 是 T 的派生类)
        ptr = other.get(); // 简化示例，实际智能指针复制更复杂
        // ... 可能需要增加引用计数等 ...
    }

    // 模板成员：模板赋值运算符
    template<typename U>
    SmartPtr& operator=(const SmartPtr<U>& other) {
        // ... 类似逻辑 ...
        return *this;
    }

    T* get() const { return ptr; }
    // ... 其他成员 ...
};

// 使用
class Base {};
class Derived : public Base {};

SmartPtr<Derived> pDerived(new Derived);
SmartPtr<Base> pBase = pDerived; // OK: 调用模板复制构造函数 SmartPtr<Base>(const SmartPtr<Derived>&)

template <typename T, template <typename U> class Container> // Container 是一个模板模板参数
class Manager {
private:
    Container<T> items; // 使用模板参数 Container 来实例化
    // ...
};

#include <vector>
#include <list>
#include "stacktp.h" // 假设 Stack<T> 在这里

template <typename T, template <typename Elem> class Container> // Container 接受一个类型参数 Elem
class Manager {
private:
    Container<T> items; // 使用 Container<T> 来存储 T 类型的元素
public:
    void add(const T& item) {
        // 假设 Container 有 push_back 或 push 方法
        // items.push_back(item); // 如果是 vector/list
        // items.push(item); // 如果是 Stack
        // 需要更通用的方式或对 Container 有要求
    }
    // ...
};

int main() {
    // 使用 std::vector 作为容器
    Manager<int, std::vector> vectorManager;
    // vectorManager.add(10);

    // 使用 std::list 作为容器
    Manager<double, std::list> listManager;
    // listManager.add(3.14);

    // 使用我们自己的 Stack 作为容器
    Manager<std::string, Stack> stackManager;
    // stackManager.add("hello");

    return 0;
}

// 为特定实例化创建别名
using AliasName = ExistingTemplate<ConcreteType>;

// 为模板本身创建别名 (参数化的别名)
template <typename T>
using AliasTemplateName = ExistingTemplate<T, SomeFixedType, ...>;

#include <vector>
#include <string>
#include <array>

// 为特定实例化创建别名
using IntVec = std::vector<int>;
using StringArray10 = std::array<std::string, 10>;

// 为模板创建别名
template<typename T>
using Vec = std::vector<T>; // Vec<T> 等价于 std::vector<T>

template<typename T>
using Array12 = std::array<T, 12>; // Array12<T> 等价于 std::array<T, 12>

int main() {
    IntVec numbers; // numbers 是 std::vector<int>
    numbers.push_back(1);

    StringArray10 names; // names 是 std::array<std::string, 10>
    names[0] = "Alice";

    Vec<double> doubles; // doubles 是 std::vector<double>
    doubles.push_back(3.14);

    Array12<char> chars; // chars 是 std::array<char, 12>
    chars[0] = 'a';

    return 0;
}