Chapter 12 类和动态内存分配

#ifndef STRINGBAD_H_
#define STRINGBAD_H_
#include <iostream>

class StringBad {
private:
    char * str;             // 指向字符串的指针
    int len;                // 字符串长度
    // 静态数据成员: 用于跟踪对象数量
    static int num_strings;

public:
    // 构造函数
    StringBad(const char * s); // 从 C 字符串构造
    StringBad();               // 默认构造函数
    // 析构函数
    ~StringBad();              // 非常重要！

    // 友元函数: 重载 <<
    friend std::ostream & operator<<(std::ostream & os, const StringBad & st);
};
#endif // STRINGBAD_H_

#include <cstring> // 为了使用 strlen, strcpy
#include "stringbad.h"

// 初始化静态类成员 num_strings
// 注意：静态数据成员必须在类定义外部进行定义和初始化
int StringBad::num_strings = 0; // 初始化为 0

// 构造函数: 从 C 字符串构造
StringBad::StringBad(const char * s) {
    len = std::strlen(s);       // 获取长度
    str = new char[len + 1];    // 分配内存 (+1 为了存储末尾的 '\0')
    std::strcpy(str, s);        // 复制字符串到新内存
    num_strings++;              // 对象计数增加
    std::cout << num_strings << ": \"" << str << "\" object created\n"; // 调试信息
}

// 默认构造函数
StringBad::StringBad() {
    len = 4;
    str = new char[4];
    std::strcpy(str, "C++");    // 默认值
    num_strings++;
    std::cout << num_strings << ": \"" << str << "\" default object created\n"; // 调试信息
}

// 析构函数
StringBad::~StringBad() {
    std::cout << "\"" << str << "\" object deleted, "; // 调试信息
    --num_strings;              // 对象计数减少
    std::cout << num_strings << " left\n"; // 调试信息
    delete [] str;              // 释放内存！
}

// 友元函数: 重载 <<
std::ostream & operator<<(std::ostream & os, const StringBad & st) {
    os << st.str;
    return os;
}

// 示例：添加一个静态成员函数到 StringBad
// stringbad.h
class StringBad {
    // ... existing private members ...
    static int num_strings;
public:
    // ... existing public members ...
    // 静态成员函数
    static int HowMany();
};

// stringbad.cpp
// ... existing code ...
// 定义静态成员函数
int StringBad::HowMany() {
    return num_strings; // 可以访问静态成员 num_strings
    // return len; // 错误！不能直接访问非静态成员 len
}

// main.cpp
#include "stringbad.h"
#include <iostream>

int main() {
    StringBad s1("Hello");
    StringBad s2("World");
    std::cout << "Number of objects: " << StringBad::HowMany() << std::endl; // 通过类名调用
    std::cout << "Number of objects: " << s1.HowMany() << std::endl;       // 通过对象调用 (不推荐)
    return 0;
}

// main_problem.cpp
#include <iostream>
#include "stringbad.h" // 假设 stringbad.h/cpp 如上定义 (没有自定义复制构造函数)

void callme1(StringBad sb) { // 按值传递，调用复制构造函数
    std::cout << "String passed by value:\n";
    std::cout << "    \"" << sb << "\"\n";
}

int main() {
    using std::cout;
    using std::endl;
    {
        cout << "Starting an inner block.\n";
        StringBad headline1("Celery Stalks at Midnight");
        StringBad headline2("Lettuce Prey");
        StringBad sports("Spinach Leaves Bowl for Dollars");

        cout << "headline1: " << headline1 << endl;
        cout << "headline2: " << headline2 << endl;
        cout << "sports: " << sports << endl;

        callme1(headline1); // 调用 callme1，headline1 被复制到参数 sb

        cout << "headline1: " << headline1 << endl; // 再次打印 headline1

        cout << "Initialize one object to another:\n";
        StringBad sailor = sports; // 调用复制构造函数

        cout << "sailor: " << sailor << endl;
        cout << "Assign one object to another:\n";
        StringBad knot; // 调用默认构造函数
        knot = headline1; // 调用赋值运算符 (这里是默认的)

        cout << "knot: " << knot << endl;
        cout << "Exiting the inner block.\n";
    } // 作用域结束，headline1, headline2, sports, sailor, knot 的析构函数被调用
    cout << "End of main()\n";
    return 0;
}

StringBad knot;        // knot.str 指向 "C++" 的内存
StringBad headline1("Celery Stalks at Midnight"); // headline1.str 指向 "Celery..." 的内存

knot = headline1; // 调用默认赋值运算符

// string1.cpp excerpt
// Copy Constructor (Deep Copy)
String::String(const String & st) {
    num_strings++;              // 更新静态计数器
    len = st.len;               // 复制长度
    str = new char [len + 1];   // *** 为新对象分配自己的内存 ***
    std::strcpy(str, st.str);   // *** 将数据复制到新内存中 ***
    // std::cout << "COPY constructor called for " << str << "\n"; // 调试信息
}

// string1.cpp excerpt
// Assignment Operator (Deep Copy)
String & String::operator=(const String & st) {
    // std::cout << "Assignment operator called for " << str << "\n"; // 调试信息
    // 1. 自我赋值检查: 防止 obj = obj; 导致意外删除
    if (this == &st)
        return *this; // 返回当前对象

    // 2. 释放旧内存: 释放当前对象 (*this) 原来占用的内存
    delete [] str;

    // 3. 深复制: 与复制构造函数类似
    len = st.len;
    str = new char [len + 1];   // 分配新内存
    std::strcpy(str, st.str);   // 复制数据

    // 4. 返回引用: 返回对调用对象 (*this) 的引用，以支持链式赋值 (a = b = c)
    return *this;
}

// string1.cpp excerpt
String::String() {                  // default constructor
    len = 0;
    str = new char[1];              // 分配足够存储空字符 '\0' 的空间
    str[0] = '\0';                  // 设置为空字符串
    num_strings++;
}

// string1.cpp excerpt (友元函数定义)
bool operator<(const String &st1, const String &st2) {
    return (std::strcmp(st1.str, st2.str) < 0);
}

bool operator>(const String &st1, const String &st2) {
    return st2 < st1; // 利用已定义的 operator<
}

bool operator==(const String &st1, const String &st2) {
    return (std::strcmp(st1.str, st2.str) == 0);
}

// string1.cpp excerpt
// read-write char access for non-const String
char & String::operator[](int i) {
    // 注意：为了简化，这里没有添加边界检查
    return str[i];
}

// read-only char access for const String
const char & String::operator[](int i) const {
    // 注意：为了简化，这里没有添加边界检查
    return str[i];
}

// string1.h excerpt
class String {
    // ...
    static int num_strings;
public:
    // ...
    static int HowMany();
};

// string1.cpp excerpt
int String::num_strings = 0; // 初始化

int String::HowMany() {
    return num_strings;
}

// string1.h excerpt
class String {
    // ...
public:
    // ...
    String & operator=(const String &); // String = String
    String & operator=(const char *);   // String = "C-string"
    // ...
};

// string1.cpp excerpt
String & String::operator=(const char * s) {
    delete [] str;                  // 释放旧内存
    len = std::strlen(s);
    str = new char[len + 1];
    std::strcpy(str, s);
    return *this;                   // 返回引用
}

// sayings1.cpp -- 使用改进的 String 类
#include <iostream>
#include "string1.h" // 使用 string1.h

const int ArSize = 10;
const int MaxLen = 81;

int main() {
    using std::cout;
    using std::cin;
    using std::endl;
    String name; // 调用默认构造函数

    cout << "Hi, what's your name?\n>> ";
    cin >> name; // 调用 operator>>

    cout << name << ", please enter up to " << ArSize
         << " short sayings <empty line to quit>:\n";
    String sayings[ArSize]; // 调用 ArSize 次默认构造函数
    char temp[MaxLen];
    int i;
    for (i = 0; i < ArSize; i++) {
        cout << i + 1 << ": ";
        cin.get(temp, MaxLen); // 读取一行
        while (cin && cin.get() != '\n') // 清除行尾换行符
            continue;
        if (!cin || temp[0] == '\0') // 检查空行或输入错误
            break; // i 未增加
        else
            sayings[i] = temp; // 调用 operator=(const char*)
    }
    int total = i; // 记录实际输入的数量

    if (total > 0) {
        cout << "Here are your sayings:\n";
        for (i = 0; i < total; i++)
            cout << sayings[i][0] << ": " << sayings[i] << endl; // 使用 operator[] 和 operator<<

        // 找到最短和第一个字母顺序最小的字符串
        int shortest = 0;
        int first = 0;
        for (i = 1; i < total; i++) {
            if (sayings[i].length() < sayings[shortest].length()) // 使用 length()
                shortest = i;
            if (sayings[i] < sayings[first]) // 使用 operator<
                first = i;
        }
        cout << "Shortest saying:\n" << sayings[shortest] << endl;
        cout << "First alphabetically:\n" << sayings[first] << endl;

        // 使用复制构造函数
        String favorite = sayings[shortest];
        cout << "My favorite saying:\n" << favorite << endl;

        cout << "This program used " << String::HowMany() << " String objects. Bye.\n"; // 使用 HowMany()
    } else {
        cout << "No input! Bye.\n";
    }

    return 0;
}

// gadget.h
#ifndef GADGET_H_
#define GADGET_H_
#include "string1.h" // 包含改进的 String 类

class Gadget {
private:
    String name; // 成员是 String 对象
    int id;
public:
    Gadget(const char * s = "Default Gadget", int i = 0) : name(s), id(i) {}
    Gadget(const String& s, int i = 0) : name(s), id(i) {}

    // *** 没有显式定义复制构造函数和赋值运算符 ***

    void show() const { std::cout << "ID: " << id << ", Name: " << name << std::endl; }
};
#endif // GADGET_H_

// main.cpp
#include <iostream>
#include "gadget.h"

int main() {
    Gadget g1("Flux Capacitor", 121);
    g1.show();

    std::cout << "\n--- Copying g1 to g2 ---\n";
    Gadget g2 = g1; // 调用 Gadget 的默认复制构造函数
    g2.show();

    std::cout << "\n--- Assigning g1 to g3 ---\n";
    Gadget g3; // 调用 Gadget 默认构造函数 (name 会调用 String 默认构造函数)
    g3.show();
    g3 = g1; // 调用 Gadget 的默认赋值运算符
    g3.show();

    std::cout << "\n--- End of main ---\n";
    return 0; // g1, g2, g3 的析构函数被调用
}

class Product {
private:
    std::string name;
    double price;
public:
    Product(const std::string& n = "N/A", double p = 0.0) : name(n), price(p) {}
    void show() const { std::cout << name << ": $" << price; }
    // ... 其他方法 ...
};

class Store {
private:
    std::vector<Product> products;
    Product defaultProduct; // 用于找不到时返回
public:
    // ... 方法添加产品 ...
    // 通过 ID 查找产品，返回 const 引用
    const Product & findProductById(int id) const {
        if (id >= 0 && id < products.size()) {
            return products[id]; // 返回 vector 中已存在对象的 const 引用
        } else {
            return defaultProduct; // 返回一个已存在的默认对象的 const 引用
        }
        // 错误示例：
        // Product temp("Temporary", 0.0);
        // return temp; // 错误！不能返回局部变量的引用
    }
};

int main() {
    Store myStore;
    // ... 添加产品到 myStore ...
    const Product & found = myStore.findProductById(1); // 高效，无复制
    found.show(); // OK: 调用 const 方法
    // found.setPrice(9.99); // 错误！不能通过 const 引用调用非 const 方法
    return 0;
}

// 在 String 类中 (来自 string1.h)
class String {
    // ...
public:
    // ...
    // 返回非 const 引用，允许修改
    char & operator[](int i);
    // 返回 const 引用，用于 const 对象
    const char & operator[](int i) const;
};

// 实现
char & String::operator[](int i) {
    return str[i]; // 返回内部 char 数组元素的引用
}
const char & String::operator[](int i) const {
    return str[i];
}

// 使用
String greeting("Hello");
greeting[0] = 'J'; // OK: 通过返回的引用修改了第一个字符
cout << greeting << endl; // 输出 Jello

const String constGreeting("Hi");
char firstChar = constGreeting[0]; // OK: 读取字符
// constGreeting[0] = 'B'; // 错误！不能修改 const 对象

// 在 Time 类中
Time& Time::operator+=(const Time& t) {
    // ... 实现加法逻辑，修改 *this ...
    return *this; // 返回调用对象自身的引用
}

// 在 Vector 类中
class Vector {
    // ...
public:
    // ...
    // 按值返回一个新的 Vector 对象
    Vector operator+(const Vector & b) const;
};

// 实现
Vector Vector::operator+(const Vector & b) const {
    // 方法 1: 创建命名对象并返回 (可能触发 NRVO)
    Vector sum(x + b.x, y + b.y);
    return sum;

    // 方法 2: 直接返回临时对象 (可能触发 RVO)
    // return Vector(x + b.x, y + b.y);
}

// 使用
Vector v1(1, 2), v2(3, 4);
Vector v3 = v1 + v2; // v1 + v2 返回一个临时 Vector 对象
                     // 这个临时对象被用来初始化 v3 (可能通过 RVO/NRVO 或移动/复制构造)

const String getName() {
    String temp = "Temporary Name";
    return temp; // 返回 const String 对象
}

int main() {
    // getName()[0] = 'X'; // 错误！不能对返回的 const 临时对象调用非 const 的 operator[]
    char first = getName()[0]; // OK: 调用 const 的 operator[]

    String nameCopy = getName(); // OK: const 临时对象可以用来初始化非 const 对象 (通过复制/移动构造)
    return 0;
}

ClassName * pointerName;

#include "string1.h" // 包含 String 类定义

String * p_string; // 声明一个指向 String 对象的指针

pointerName = new ClassName; // 调用默认构造函数
pointerName = new ClassName(arguments); // 调用匹配参数的构造函数

#include "string1.h"
#include <iostream>

int main() {
    using std::cout;
    using std::endl;

    String * p1 = new String("Dynamically allocated string"); // 调用 String(const char*)
    String * p2 = new String; // 调用默认构造函数 String()

    cout << "p1 points to: " << *p1 << endl; // 使用 * 解引用指针访问对象
    cout << "p2 points to: " << *p2 << endl;

    // ... 使用 p1 和 p2 指向的对象 ...
}

delete pointerName;

// main.cpp (续)
int main() {
    // ... (创建 p1, p2 的代码) ...

    cout << "\nDeleting objects...\n";
    delete p1; // 调用 ~String() for *p1，然后释放内存
    delete p2; // 调用 ~String() for *p2，然后释放内存

    // p1 和 p2 现在是悬挂指针，不应再使用
    p1 = nullptr;
    p2 = nullptr;

    return 0;
}

int size = 5;
String * favorites = new String[size]; // 调用 size 次默认构造函数

// ... 使用数组 ...

delete [] favorites; // 调用 size 次析构函数，然后释放整个数组内存

#include "string1.h"
#include <iostream>

int main() {
    String * glamour = new String("Glamorous");

    // 使用箭头运算符访问成员
    std::cout << "String: " << glamour->operator const char *() << std::endl; // 假设有转换函数
    std::cout << "Length: " << glamour->length() << std::endl; // 调用 length() 方法
    std::cout << "First char: " << (*glamour)[0] << std::endl; // 混合使用 * 和 []
    std::cout << "First char again: " << glamour->operator[](0) << std::endl; // 使用 -> 调用 operator[]

    delete glamour;
    return 0;
}

#include <new> // 必须包含 <new> 头文件

BufferType * buffer = /* ... 获取指向已分配内存的指针 ... */;
ClassName * ptr;

ptr = new (buffer) ClassName(arguments); // 在 buffer 指向的内存上构造对象

ptr->~ClassName(); // 显式调用析构函数

#include <iostream>
#include <new>      // for placement new
#include "string1.h" // 假设 String 类有默认和 C-string 构造函数及析构函数

const int BUF = 512;
char buffer[BUF]; // 预先分配的内存缓冲区 (静态存储)

int main() {
    using std::cout;
    using std::endl;

    String *p1, *p2;

    cout << "Block 1: placement new in buffer:\n";
    p1 = new (buffer) String("Hello"); // 在 buffer 开始处构造 String("Hello")
    // 计算 buffer 中下一个可用地址
    // 注意：这只是一个简化示例，实际内存池管理需要更复杂的对齐和大小计算
    size_t available_space = BUF - sizeof(String);
    void * next_loc = buffer + sizeof(String);

    if (available_space >= sizeof(String)) {
         p2 = new (next_loc) String("World"); // 在 buffer 的下一个位置构造 String("World")
    } else {
         cout << "Not enough space for p2.\n";
         p2 = nullptr;
    }


    cout << "Memory addresses:\n" << "buffer: " << (void *) buffer
         << "  p1: " << p1 << "  p2: " << p2 << endl;

    cout << "p1: " << *p1 << endl;
    if (p2) cout << "p2: " << *p2 << endl;

    // 显式销毁对象 (按构造相反顺序通常是好习惯)
    cout << "\nDestroying objects:\n";
    if (p2) {
        p2->~String(); // 调用 p2 指向对象的析构函数
        cout << "p2 destroyed.\n";
    }
    p1->~String();     // 调用 p1 指向对象的析构函数
    cout << "p1 destroyed.\n";

    // buffer 内存本身会在 main 结束时自动释放 (因为它是栈上的数组)

    cout << "\nBlock 2: Standard new/delete:\n";
    String * p3 = new String("Standard new");
    cout << "p3: " << *p3 << " at " << p3 << endl;
    delete p3; // 使用标准 delete，它会调用析构函数并释放内存
    cout << "p3 deleted.\n";

    return 0;
}

// string1.h excerpt
class String {
    // ... private: char * str; int len; ...
    friend std::ostream & operator<<(std::ostream & os, const String & st);
    // ...
};

// string1.cpp excerpt
std::ostream & operator<<(std::ostream & os, const String & st) {
    os << st.str; // 友元函数访问私有成员 str
    return os;
}

// 使用
String greeting("Hello");
std::cout << "Message: " << greeting << std::endl; // 调用 operator<<(cout, greeting)

// stones.h excerpt
class Stones {
    // ... private: double pounds; ...
public:
    // ...
    explicit operator double() const; // 显式转换为 double
    explicit operator int() const;    // 显式转换为 int
};

// stones.cpp excerpt
Stones::operator double() const {
    return pounds;
}
Stones::operator int() const {
    return int(pounds + 0.5); // 四舍五入
}

// 使用
Stones stone_obj(100.7);
// double weight = stone_obj; // 错误！因为是 explicit
double weight = static_cast<double>(stone_obj); // OK: 显式转换
int int_weight = static_cast<int>(stone_obj);    // OK: 显式转换
std::cout << "Weight: " << weight << std::endl;

// string1.h excerpt
class String {
private:
    char * str;
    int len;
    // ...
public:
    String(const char * s); // Constructor using new
    String(const String & st); // Copy constructor (deep copy)
    ~String(); // Destructor using delete[]
    String & operator=(const String & st); // Assignment operator (deep copy)
    String & operator=(const char * s);   // Another assignment overload
    // ...
};

// string1.cpp excerpt (实现深复制)
String::String(const String & st) { // Copy Constructor
    len = st.len;
    str = new char [len + 1];
    std::strcpy(str, st.str);
    // ... (update static count etc.)
}

String::~String() { // Destructor
    delete [] str;
    // ... (update static count etc.)
}

String & String::operator=(const String & st) { // Assignment Operator
    if (this == &st)
        return *this;
    delete [] str; // Free old string
    len = st.len;
    str = new char [len + 1];
    std::strcpy(str, st.str);
    return *this;
}

#ifndef QUEUE_H_
#define QUEUE_H_

// 前向声明 Customer 类
class Customer;

// 为了简化，我们直接使用 Customer 类型，而不是模板
typedef Customer Item;

class Queue {
private:
    // 内部节点结构
    struct Node {
        Item item;      // 存储的数据 (Customer 对象)
        Node * next;    // 指向下一个节点的指针
    };
    enum { Q_SIZE = 10 }; // 默认队列大小 (可以修改)

    Node * front;       // 指向队首的指针
    Node * rear;        // 指向队尾的指针
    int items;          // 当前队列中的项目数
    const int qsize;    // 队列最大容量 (const 成员)

    // 复制构造函数和赋值运算符设为私有，以禁止复制 (简单处理方式)
    // 如果需要复制，则需要实现深复制
    Queue(const Queue & q) : qsize(0) { }
    Queue & operator=(const Queue & q) { return *this; }

public:
    // 构造函数，可以指定最大容量
    Queue(int qs = Q_SIZE);
    // 析构函数
    ~Queue();

    bool isempty() const { return items == 0; }
    bool isfull() const { return items == qsize; }
    int queuecount() const { return items; }

    // 添加项目到队尾
    bool enqueue(const Item &item);
    // 从队首移除项目
    bool dequeue(Item &item); // item 用于接收出队的数据
};
#endif // QUEUE_H_

#include "queue.h"
#include <cstdlib> // for std::rand() - 仅用于 Customer 示例，Queue 本身不需要

// --- Customer 类定义 (简单版本，放在这里仅为编译 Queue) ---
// 实际应用中应放在单独的 customer.h/cpp
class Customer {
private:
    long arrive;        // arrival time for customer
    int processtime;    // processing time for customer
public:
    Customer() : arrive(0), processtime(0) {} // default constructor
    void set(long when) {
        processtime = std::rand() % 3 + 1; // 随机处理时间 1-3 分钟
        arrive = when;
    }
    long when() const { return arrive; }
    int ptime() const { return processtime; }
};
// --- Customer 类定义结束 ---


// Queue 方法实现
Queue::Queue(int qs) : qsize(qs) { // 初始化 const 成员 qsize
    front = rear = nullptr; // 初始化为空队列
    items = 0;
}

Queue::~Queue() {
    Node * temp;
    while (front != nullptr) { // 循环直到队列为空
        temp = front;          // 保存当前队首节点地址
        front = front->next;   // 移动 front 指向下一个节点
        delete temp;           // 删除旧的队首节点
    }
}

// 添加项目到队尾
bool Queue::enqueue(const Item &item) {
    if (isfull())
        return false; // 队列已满，无法添加

    Node * add = new Node; // 创建新节点
    // 如果 new 失败，会抛出异常 (这里简化处理，未捕获)
    add->item = item;      // 设置节点数据
    add->next = nullptr;   // 新节点是队尾，next 为空
    items++;               // 项目数增加

    if (front == nullptr)  // 如果队列原本为空
        front = add;       // 新节点同时是队首和队尾
    else
        rear->next = add;  // 将原队尾节点的 next 指向新节点
    rear = add;            // 更新 rear 指向新的队尾节点
    return true;
}

// 从队首移除项目
bool Queue::dequeue(Item &item) {
    if (isempty())
        return false; // 队列为空，无法移除

    item = front->item;    // 获取队首节点的数据 (通过引用参数返回)
    items--;               // 项目数减少
    Node * temp = front;   // 保存队首节点地址
    front = front->next;   // 移动 front 指向下一个节点
    delete temp;           // 删除旧的队首节点

    if (items == 0)        // 如果删除后队列为空
        rear = nullptr;    // rear 也设为空
    return true;
}

// customer.h (理想情况下)
#ifndef CUSTOMER_H_
#define CUSTOMER_H_

class Customer {
private:
    long arrive;        // arrival time for customer
    int processtime;    // processing time for customer
public:
    Customer() : arrive(0), processtime(0) {}
    void set(long when); // 设置到达时间，并随机生成处理时间
    long when() const { return arrive; }
    int ptime() const { return processtime; }
};
#endif // CUSTOMER_H_

// customer.cpp (理想情况下)
#include "customer.h"
#include <cstdlib> // for std::rand()

void Customer::set(long when) {
    processtime = std::rand() % 3 + 1; // 假设处理时间为 1, 2, 或 3 分钟
    arrive = when;
}

#include <iostream>
#include <cstdlib> // for rand() and srand()
#include <ctime>   // for time()
#include "queue.h" // 包含 Queue 类 (它内部包含了 Customer 的简单定义)

const int MIN_PER_HR = 60; // 每小时分钟数

// 函数：判断是否有新客户到来
// 参数 x: 平均多少分钟来一位客户
// 返回值: true 如果这一分钟有客户来, false 如果没有
bool newcustomer(double x);

int main() {
    using std::cin;
    using std::cout;
    using std::endl;
    using std::ios_base;

    // 设置随机数种子
    std::srand(std::time(0));

    cout << "Case Study: Bank of Heather Automatic Teller\n";
    cout << "Enter maximum size of queue: ";
    int qs; // 队列最大长度
    cin >> qs;
    Queue line(qs); // 创建队列对象

    cout << "Enter the number of simulation hours: ";
    int hours; // 模拟总小时数
    cin >> hours;
    // 模拟以分钟为单位进行
    long cyclelimit = MIN_PER_HR * hours; // 总模拟分钟数

    cout << "Enter the average number of customers per hour: ";
    double perhour; // 平均每小时客户数
    cin >> perhour;
    double min_per_cust; // 平均多少分钟来一位客户
    min_per_cust = MIN_PER_HR / perhour;

    Item temp;          // 用于存储新客户
    long turnaways = 0; // 因队列满而被拒绝的客户数
    long customers = 0; // 加入队列的总客户数
    long served = 0;    // 完成服务的总客户数
    long sum_line = 0;  // 累计的队列长度 (用于计算平均长度)
    int wait_time = 0;  // 当前客户在 ATM 处还需等待的时间
    long line_wait = 0; // 所有客户累计的总等待时间 (队列中 + ATM处)

    // --- 模拟主循环 ---
    for (long cycle = 0; cycle < cyclelimit; cycle++) {
        // 1. 是否有新客户到来？
        if (newcustomer(min_per_cust)) {
            if (line.isfull()) {
                turnaways++; // 队列满，拒绝
            } else {
                customers++; // 客户加入
                temp.set(cycle); // 设置客户到达时间 (当前分钟数) 和随机处理时间
                line.enqueue(temp); // 加入队列
            }
        }

        // 2. ATM 是否空闲？如果空闲且队列有人，则服务下一位
        if (wait_time <= 0 && !line.isempty()) {
            line.dequeue(temp); // 从队列取出客户
            wait_time = temp.ptime(); // 设置 ATM 需等待时间 = 客户处理时间
            line_wait += cycle - temp.when(); // 累加客户等待时间 (当前时间 - 到达时间)
            served++; // 服务客户数增加
        }

        // 3. 如果 ATM 正在服务，则减少剩余等待时间
        if (wait_time > 0)
            wait_time--;

        // 4. 累加当前队列长度
        sum_line += line.queuecount();
    }
    // --- 模拟循环结束 ---

    // --- 输出模拟结果 ---
    if (customers > 0) {
        cout << "\nCustomers accepted: " << customers << endl;
        cout << "  Customers served: " << served << endl;
        cout << "         Turnaways: " << turnaways << endl;
        cout << "Average queue size: ";
        cout.precision(2);
        cout.setf(ios_base::fixed, ios_base::floatfield);
        cout << (double) sum_line / cyclelimit << endl; // 平均队列长度
        cout << " Average wait time: "
             << (double) line_wait / served << " minutes\n"; // 平均等待时间
    } else {
        cout << "No customers!\n";
    }

    cout << "Done!\n";

    return 0;
}

// 函数定义：判断是否有新客户到来
// 这是一个简单的概率模型：在一分钟内，客户到来的概率是 1/x
bool newcustomer(double x) {
    // rand() * x / RAND_MAX < 1  等价于 rand() / RAND_MAX < 1/x
    return (std::rand() * x / RAND_MAX < 1);
}