Lab7: 面向对象程序构造方法及创新应用 (基础)
1、实现一个自定义字符串类型 String，使之具有与 int 等基本类型相同的使用方式。(注:含类、构造、析构、重载等机制运用)
需要分清默认构造函数、拷贝构造函数、带参数构造函数和重载的赋值运算符。
其中加法重载稍微复杂一点。
代码
#include <iostream>
#include <cstring>
class String {
private:
char* data; // 字符串数据
size_t length; // 字符串长度
public:
// 默认构造函数
String() : data(NULL), length(0) {puts("默认构造");}
// 构造函数
String(const char* str) {
puts("带参数构造");
length = strlen(str); // 获取字符串长度
data = new char[length + 1]; // 分配内存
strcpy(data, str); // 复制字符串
}
// 拷贝构造函数
String(const String& other) {
length = other.length; // 获取字符串长度
data = new char[length + 1]; // 分配内存
strcpy(data, other.data); // 复制字符串
}
// 析构函数
~String() {
puts("析构");
delete[] data; // 释放内存
}
// 重载相加运算符
String operator+(const String& other) const {
String result;
result.length = length + other.length; // 计算结果长度
result.data = new char[result.length + 1]; // 分配内存
strcpy(result.data, data); // 复制当前字符串
strcat(result.data, other.data); // 连接另一个字符串
return result;
}
// 重载相等运算符
bool operator==(const String& other) const {
return strcmp(data, other.data) == 0;
}
// 重载输出运算符
friend std::ostream& operator<<(std::ostream& os, const String& str) {
os << str.data;
return os;
}
};
int main() {
String str1 = "Hello";
String str2 = "World";
String str3 = str1 + str2;
String str4;
//str4 = str1 + str2; 这一行要用到重载赋值运算符
std::cout << str1 << std::endl;
std::cout << str2 << std::endl;
std::cout << str3 << std::endl;
if (str1 == str2) {
std::cout << "str1 and str2 are equal" << std::endl;
} else {
std::cout << "str1 and str2 are not equal" << std::endl;
}
return 0;
}
/*
// 重载赋值运算符
String& operator=(const String& other) {
if (this != &other) {
delete[] data; // 释放原有内存
length = other.length; // 获取字符串长度
data = new char[length + 1]; // 分配新内存
strcpy(data, other.data); // 复制字符串
}
return *this;
}
*/
输出
2、实现一个“字”类型，并通过继承和多态机制分别实现“字”的不同显示、不同字体、不同大小等等。
在上述代码中，我们定义了一个基类 Character，它表示一个字，并具有纯虚函数 display() 用于显示字的内容。然后，我们派生出了三个子类：SongTiCharacter（宋体字）、HeiTiCharacter（黑体字）和 BoldCharacter（加粗字）。每个子类都重写了基类的 display() 函数，以实现不同的显示方式。
在 main() 函数中，我们创建了一个指向基类的指针数组 characters，并分别使用派生类的构造函数创建了三个不同的字对象。通过循环遍历数组，并调用 display() 函数，实现了多态的效果。最后，记得释放动态分配的内存。
代码
#include <iostream>
#include <string>
// 基类：字
class Character {
protected:
std::string content;
public:
Character(const std::string& content) : content(content) {}
virtual ~Character() {}
virtual void display() const = 0;
};
// 派生类：宋体字
class SongTiCharacter : public Character {
public:
SongTiCharacter(const std::string& content) : Character(content) {}
void display() const {
std::cout << "宋体字：" << content << std::endl;
}
};
// 派生类：黑体字
class HeiTiCharacter : public Character {
public:
HeiTiCharacter(const std::string& content) : Character(content) {}
void display() const {
std::cout << "黑体字：" << content << std::endl;
}
};
// 派生类：加粗字
class BoldCharacter : public Character {
public:
BoldCharacter(const std::string& content) : Character(content) {}
void display() const {
std::cout << "加粗字：" << content << std::endl;
}
};
int main() {
Character* characters[3];
characters[0] = new SongTiCharacter("你好");
characters[1] = new HeiTiCharacter("Hello");
characters[2] = new BoldCharacter("Bonjour");
for (int i = 0; i < 3; i++) {
characters[i]->display();
delete characters[i];
}
return 0;
}
输出
3、I/O 流基本应用
通过文件流读取两个含有若干整数的文本文件，将这些整数排序后写入另一个文本文件中。
代码
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
int main() {
// 读取第一个文件的整数
std::ifstream file1("file1.txt");
if (!file1) {
std::cerr << "无法打开文件1" << std::endl;
return 1;
}
std::vector<int> numbers;
int num;
while (file1 >> num) {
numbers.push_back(num);
}
file1.close();
// 读取第二个文件的整数
std::ifstream file2("file2.txt");
if (!file2) {
std::cerr << "无法打开文件2" << std::endl;
return 1;
}
while (file2 >> num) {
numbers.push_back(num);
}
file2.close();
// 对整数进行排序
std::sort(numbers.begin(), numbers.end());
// 写入结果到第三个文件
std::ofstream outputFile("output.txt");
if (!outputFile) {
std::cerr << "无法打开输出文件" << std::endl;
return 1;
}
for (size_t i = 0; i < numbers.size(); i++) {
outputFile << numbers[i] << " ";
}
outputFile.close();
std::cout << "排序完成，结果已写入output.txt文件" << std::endl;
return 0;
}
输出(输入输出均在文件内)
排序完成，结果已写入output.txt文件
1 2 3 4 5 6 7 8
4、通过扩展方式定义一个自己的异常类并进行验证。
在这个示例中，我们定义了一个自定义的异常类 MyException，它继承自 std::exception。 what() 函数返回异常消息的字符串表示。
在 divide() 函数中，如果除数为零，我们抛出一个 MyException 异常，并将异常消息作为参数传递给异常的构造函数。
代码
#include <iostream>
#include <stdexcept>
// 自定义异常类
class MyException : public std::exception {
private:
std::string message;
public:
MyException(const std::string& msg) : message(msg) {}
~MyException() throw() {}
const char* what() const throw() {
return message.c_str();
}
};
// 函数：除法运算
double divide(double dividend, double divisor) {
if (divisor == 0.0) {
throw MyException("除数不能为零");
}
return dividend / divisor;
}
int main() {
try {
double result = divide(10.0, 0.0);
std::cout << "结果：" << result << std::endl;
} catch (const MyException& ex) {
std::cerr << "捕获到自定义异常：" << ex.what() << std::endl;
}
return 0;
}
输出
