//复习用，如有错误，请指正
1.下面程序的输出是什么?
#include < iostream >
using namespace std;
int main(){
int x = 10;
int& ref = x;
ref = 20;
cout <<"x = "<< x << endl ;
x = 30;
cout <<"ref = " << ref << endl;
return 0;
}2.关于下列程序,正确的是:
A.运行时错误 B.编译时错误 C.没问题 D.0
# include < iostream >
using namespace std;
int &fun( ){
int x = 10;
return x;
}
int main(){
fun() = 30;
cout << fun();
return 0;
}答：A
在 fun 函数中，将局部变量 x 的引用返回给了 main 函数。然而，一旦 fun 函数执行完毕，x 变量就会被销毁，这意味着在 main 函数中对其赋值是不安全的。因此，会导致运行时错误。
3.下面哪个定义是非法的?为什么?
(1) int ival=1.01; (2) int &rvall = 1.01;
(3) int &rval2 = ival; (4) int &rval3;
答：
(1) int ival=1.01; 是合法的，虽然浮点数被赋给了整型变量，但会进行隐式类型转换。
(2) int &rvall = 1.01;是非法的，引用必须绑定到一个具体的对象上。在这种情况下，引用 rvall 尝试绑定到字面常量 1.01 上，这是不允许的。只有左值才可以作为引用的初始器，而字面常量是右值，不能直接绑定到引用上。
(3) int &rval2 = ival; 是合法的，引用 rval2 绑定到了 ival 的地址。
(4) int &rval3; 是非法的，引用必须在定义时初始化，否则会导致编译错误。
4.下列代码的输出是什么?
int i,&ri = i;
i= 5;ri = 10;
std::cout < i<< " "<< ri < std::endl;答：10 10
5.请叙述下面这段代码的作用。
int i = 42;
int *pl = &i;
*pl = *pl * *pl;答：
int i = 42;：定义一个整型变量 i，并将其初始化为 42。
int *pl = &i;：定义一个整型指针 pl，并将其初始化为指向变量 i 的地址。
*pl = *pl * *pl;：对指针 pl 所指向的变量进行操作。首先，通过 *pl 取得指针所指向的变量 i 的值，然后将此值与自身相乘，最后将结果赋给 i。
因此，这段代码的作用是让变量 i 的值变为原来的值的平方，即 42 的平方，结果为 1764。
6.解释下列语句的含义,并说明错的语句的原因。
int i=0;
A.double* dp= &i;
B.int *ip=i;
C.int *p= &i;
答：
A.double* dp= &i; //i是int型的变量，而dp是指向double型变量的指针
B.int *ip=i;//ip应赋值为i的地址，即&i而不是i的值
C.int *p= &i;//正确，p是指向i的指针
7.下面这段代码中为什么 p 合法而 lp 非法?
int i = 42;
void *p = &i;
long *lp = &i;答：
void *p = &i;：void* 是一种通用的指针类型，可以指向任意类型的对象。所以将 &i（int 类型的地址）赋给 void* 类型的指针 p 是合法的。
long *lp = &i;：虽然 &i 是一个有效的地址，但是将 &i 赋给 long* 类型的指针 lp 是非法的。long* 是一个指向 long 类型对象的指针类型，而 &i 是一个指向 int 类型对象的地址。类型不匹配，无法隐式转换。
8.说明下述变量的类型和值
(1)int* ip，*&r=ip;
(2) int i,*ip= 0;
(3) int* ip,ip2;
答：
(1)int* ip，*&r=ip;//ip是指向int型变量的指针，&r=ip 表示r是一个引用，指向ip所指向的整型数据。r的类型为int，其值为ip所指向的地址。
(2) int i,*ip= 0;//i是int型的变量，ip是指向int型变量的指针，初始值为0（空指针）
(3) int* ip,ip2;//ip是指向int型变量的指针，ip2是int型的变量
9.下列哪些数组定义有错误? 为什么?
unsigned buf_size = 1024;
(1) int ia[buf size];
(2) int ib[4 * 7-24];
(3) int ic[4 * 7-28];
(4) char st[11] = “hello world";
答：
(1) int ia[buf size]; 这个数组定义是错误的，因为在定义数组时不能使用变量作为数组的大小。应该使用常量来定义数组的大小。
(4) char st[11] = "hello world"; 这个数组定义也是错误的，因为字符串"hello world"有12个字符，但是数组的大小只定义为11，不足以容纳整个字符串。应该将数组大小设置为12，以容纳完整的字符串。
10.找出下列程序中的错误。
int v[] = { 1,2,3,4};
v0= 10.5;
int i = v[3] + 10;
v[2] = v[0] - i;
i = v[4];答：
v0= 10.5;：这里应该是对数组 v 的第一个元素进行赋值。正确的写法应该是 v[0] = 10.5;。
i = v[4];：数组 v 中只有四个元素（下标从 0 到 3），所以访问 v[4] 越界了。
11.下面哪句是不合法的?原因是什么?
(1) const int buf;
(2) int cnt = 0;
(3) const int sz = cnt;
(4) ++cnt; ++sz;
答：
(1) 不合法，const对象一旦创建后不能改变，所以const对象必须初始化
（4）不合法，sz是const对象，不能自增。
12.下面哪句是不合法的? 原因是什么?
(1)int i=-1,&r= 0;
(2) const int i2=i,&r2 = i;
(3) const int i3=-i, &r3 = 0;
(4) const int *p1 = &i2;
(5)int * const p2 = &i2;
(6) const int * const p3 = &i2;
(7) const int & const r4;
答：
（1）int i = -1, &r = 0; // 不合法， r为引用，初始化只能指向一个对象。
（2）int *const p2 = &i2; // 合法，定义一个int型的常量指针，初始化为i2的地址，之后指针的值不能再改变
（3）const int i = -1, &r = 0; // 合法， r为引用，const int &r = 0; 是合法的。
（4）const int* const p3 = &i2; // 合法，p3的值不能改变，*p3也不能改变
（5）const int* p1 = &i2; // 合法，指针常量，p1指向的值不能被改变
（6）const int& const r2; // 不合法，引用不能是const
（7）const int i2 = i, &r = i; // 合法
13.下面代码中哪些语句是错误的? 为什么?
int a[5] ={};
int b[6] ={};
int* x = a;
int* const y = a;
b = x;
x = b;
y = b;答：
b = x; 这一行是错误的，因为数组名不能被赋值，数组名代表的是数组首元素的地址，它是一个常量指针。
y = b; 这一行也是错误的，因为 y 被声明为一个指向整型常量的指针，因此不能再改变指向其他地址。
14.下面代码中的变量 p1、ci、p2、p3、r 能否被修改?
int i{0};
int *const p1 = &i;
const int ci = 42;
const int *p2 = &ci;
const int *const p3 = p2;
const int &r = ci;答：
p1 是一个常量指针，指向 i，p1 本身是一个常量，不能被修改，但是可以通过 p1 来修改 i 的值。
ci 是一个常量整数，不能被修改。
p2 是一个指向常量整数的指针，指向 ci，p2 可以通过改变指向的对象来修改 ci 的值，但是 p2 本身是一个常量指针，不能被修改。
p3 是一个指向常量整数的常量指针，指向 p2，p3 本身是一个常量，不能被修改，但是可以通过 p3 来修改 ci 的值。
r 是一个整数的常量引用，不能被修改。
15.在第 14 题的基础上,下面定义的变量有没有错误? 为什么?
int *p = p3;
p2 = p3;
p2 = &i;
int &rl = ci;
const int &r2 = i;答：
int *p = p3;：这行代码是错误的。p3 是一个指向常量整数的常量指针，不能将其赋给一个普通的指针 p。应该改为 const int *p = p3;。
p2 = p3;：这行代码是合法的。p2 是一个指向常量整数的指针，可以通过改变指向的对象来修改 ci 的值，而 p3 也是一个指向常量整数的指针，因此可以将 p3 的值赋给 p2。
p2 = &i;：这行代码是错误的。p2 是一个指向常量整数的指针，不能将 &i（非常量整数的地址）赋给它。应该改为 const int *p2 = &i;。
int &rl = ci;：这行代码是错误的。rl 是一个整数的引用，但 ci 是一个常量整数，不能将一个非常量引用绑定到常量上。应该改为 const int &rl = ci;。
const int &r2 = i;：这行代码是合法的。r2 是一个常量引用，可以将非常量 i 绑定到常量引用上。
16.下面哪句是不合法的?原因是什么?
(1) int i,*const cp;
(2)int *p1，*const p2;
(3) const int ic,&r = ic;
(4) const int *const p3;
(5) const int *p;
答：
const int *const p3;：这句代码是不合法的。声明了一个常量指针 p3，但没有为其初始化，常量指针必须在声明时进行初始化。
17.对于第 16 题中的变量,下面哪句是不合法的?原因是什么?
(1)i= ic;
(2) p1= p3;
(3) p1=
(4) p3=
(5) p2 = p1;
(6)ic=*p3;
答：
(1)i = ic;：这句代码是合法的。将常量整数 ic 的值赋给非常量整数 i 是允许的。
(2) p1 = p3;：这句代码是合法的。将指向常量整数的指针 p3 赋给指向非常量整数的指针 p1 是允许的。指针类型可以宽松地转换为其他类型的指针。
(3) p1 = ：这句代码是不合法的。p1 是一个指向非常量整数的指针，不能将指向常量整数 ic 的地址赋给它。
(4) p3 = ：这句代码是不合法的。p3 是一个常量指针，它的指向不可以改变。
(5) p2 = p1;：这句代码是合法的。
(6) ic = *p3;：这句代码是不合法的。ic 是一个常量整数，不能修改其值。
18.下面哪句是不合法的? 原因是什么?
int i= 0;
int *const p1 = &i;
const int ci = 42;
const int *p2 = &ci;
const int *const p3 = p2;
const int &r = ci;
int *p = p3;
p2= p3;
p2 = &i;
int &r = ci;
const int &r2 = i;答：
int i= 0;
int *const p1 = &i; // 合法，p1 是一个指向 int 类型的常量指针，指向 i
const int ci = 42;
const int *p2 = &ci; // 合法，p2 是一个指向常量 int 类型的指针，指向 ci
const int *const p3 = p2; // 合法，p3 是一个指向常量 int 类型的常量指针，指向 p2 所指的对象 ci
const int &r = ci; // 合法，r 是一个对常量 int 的引用，引用了 ci
int *p = p3; // 不合法，p 是一个指向 int 类型的指针，而 p3 是一个指向常量 int 类型的常量指针，类型不匹配
p2= p3; // 合法，p2 是一个指向常量 int 类型的指针，可以将 p3 赋值给它
p2 = &i; // 不合法，p2 是一个指向常量 int 类型的指针，不可以指向 i
int &r = ci; // 不合法，r 是一个对int 的引用，不能引用常量对象 ci
const int &r2 = i; // 合法，r2 是一个对常量 int 的引用，可以引用非常量对象 i19.说明下列哪些变量是 const 对象，哪些是指向或引用 const 对象的指针或引用.
const int v2 = 0;
int v1= v2;
int *p1 = &v1,&r1 = v1;
const int *p2 = &v2，*const p3 = &v2,&r2 = v2;答：
const对象：v2;
指向或引用 const 对象的指针或引用:p2,p3,r2;
20.对于第 19 题中的变量,下列哪些语句是合法的?哪些是非法的?为什么?
r1 = v2;
p1 = p2;
p2 = p1;
p1 = p3;
p2 = p3;答：
合法的语句：
- r1 = v2; // 因为 r1 是指向非 const 对象 v1 的引用，可以修改其值。
非法的语句：
- p2 = p1; // p2 是指向 const 对象的指针，不能指向非 const 对象的地址。
- p1 = p3; // p1 是指向非 const 对象的指针，不能指向指向 const 对象的地址。
- p1 = p3; // 因为 p1 是指向非 const 对象的指针，不可以指向const对象v2。
- p2 = p3; // p2 是指向 const 对象的指针，不能指向指向 const 对象的地址。
21.编写程序从键盘输入 10 个整数到一个数组中,并将数组中的元素逆序放入另外一个数组中，最后输出这两个数组中的所有整数。
答：
#include <iostream>
using namespace std;
int main() {
const int size = 10;
int arr1[size];
int arr2[size];
// 从键盘输入10个整数到arr1数组中
cout << "请输入10个整数：" << endl;
for (int i = 0; i < size; i++) {
cin >> arr1[i];
}
// 将arr1数组中的元素逆序放入arr2数组中
for (int i = 0; i < size; i++) {
arr2[i] = arr1[size - 1 - i];
}
// 输出arr1数组中的所有整数
cout << "arr1数组中的整数为：" << endl;
for (int i = 0; i < size; i++) {
cout << arr1[i] << " ";
}
cout << endl;
// 输出arr2数组中的所有整数
cout << "arr2数组中的整数为：" << endl;
for (int i = 0; i < size; i++) {
cout << arr2[i] << " ";
}
cout << endl;
return 0;
}22.从键盘输入 10 个整数到一个数组中,然后历数组求出这些整数中的最大值、最小值并输出。
答：
#include <iostream>
using namespace std;
int main() {
const int size = 10;
int arr[size];
// 从键盘输入10个整数到arr数组中
cout << "请输入10个整数：" << endl;
for (int i = 0; i < size; i++) {
cin >> arr[i];
}
// 求出这些整数中的最大值和最小值
int maxNum = arr[0];
int minNum = arr[0];
for (int i = 1; i < size; i++) {
if (arr[i] > maxNum) {
maxNum = arr[i];
}
if (arr[i] < minNum) {
minNum = arr[i];
}
}
// 输出最大值和最小值
cout << "最大值为：" << maxNum << endl;
cout << "最小值为：" << minNum << endl;
return 0;
}23.编写程序,输出一个乘法口诀表。
答：
#include <iostream>
using namespace std;
int main() {
// 输出乘法口诀表
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
cout << j << " * " << i << " = " << i * j << "\t";
}
cout << endl;
}
return 0;
}24.将下列程序改成用 auto 和 rang for。
#include<iostream>
int main(){
//声明一个 10 x10 的数组
const int numRows = 10;
const int numCols = 10;
int product[numRows][numCols] = {0} ;
//计算乘法表
for (int row = 0; row < numRows; ++row)
for (int col = 0; col < numCols; ++col)
product[row][col] = row * col;
//打印表
for (int row = 1; row < numRows; ++row){
for (int col = 1; col < numCols; ++col)
std::cout<<product[row][col] <"\t";
std::cout<<’\n';
}
return 0;
}答：
#include <iostream>
int main() {
// 声明一个 10 x 10 的数组
const int numRows = 10;
const int numCols = 10;
int product[numRows][numCols] = {0};
// 计算乘法表
for (auto row=0;row<numRows;++row) {
for (auto col=0;col<numCols;++col) {
product[row][col]=row*col;
}
}
// 打印表
for (auto& row : product) {
for (auto& col : row) {
if(col!=0) std::cout << col << '\t';
}
std::cout << '\n';
}
return 0;
}25.下面程序的输出是什么?
# include < iostream >
int main(){
int i= 1;
int const& a = i>0?i:0;
i = 2;
std:: cout << i << a;
}答：2 1
26.关于下面代码,正确的输出是( )。
A.3
B.0x822222232
C.语法错误
D.不确定
# include < iostream >
int main(int argc,char ** argv){
//假设 x的地址是 0x822222232
int x = 3;
int*& rpx = &x;
std:: cout << rpx << std::endl;
}答：B
27.解释下列程序
const char *cp = ca;
while( *cp){
cout << * cp << endl;
++cp;
}答：
首先将字符数组 ca 的首地址赋值给指针 cp。
然后，进入一个循环，条件是 *cp，也就是指针 cp 指向的字符不为 '\0'（空字符）。
在循环体内，首先通过 cout << *cp << endl; 打印指针 cp 指向的字符，然后通过 ++cp; 将指针 cp 向后移动一个位置，指向下一个字符。
这样循环会一直进行，直到遇到空字符 '\0'，即字符数组的结尾。循环结束后，所有的字符都被逐个输出到屏幕上。
28.从网上搜索表 5-1 中的 C 风格字符串处理函数的作用,并编写程序学习这些函数的使用。
答：
strlen：用于计算字符串的长度。
strcpy：用于将一个字符串复制到另一个字符串。
strcat：用于将一个字符串连接到另一个字符串的末尾。
strcmp：用于比较两个字符串。
strchr：用于在字符串中查找特定字符的第一次出现。
strstr：用于在字符串中查找子字符串的第一次出现。
#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "Hello";
char str2[] = "World";
char str3[20];
// 计算字符串的长度
printf("Length of str1: %lu\n", strlen(str1));
// 复制字符串
strcpy(str3, str1);
printf("str3 after strcpy: %s\n", str3);
// 连接字符串
strcat(str3, " ");
strcat(str3, str2);
printf("str3 after strcat: %s\n", str3);
// 比较字符串
if (strcmp(str1, str2) == 0) {
printf("str1 and str2 are equal\n");
} else {
printf("str1 and str2 are not equal\n");
}
// 查找字符
char *ptr = strchr(str3, 'W');
printf("Character 'W' found at position: %ld\n", ptr - str3);
// 查找子字符串
char *sub = strstr(str3, "World");
printf("Substring 'World' found at position: %ld\n", sub - str3);
return 0;
}29.下面的函数 Strlen()是模拟 C风格字符串处理函数 strlen(),请补充其代码,并运行程序测试这个函数
int Strlen(const char * str)(
//编写你的代码
//...
}
#include < iostream >
# include < cstring>
using namespace std;
int main( ){
char *s = "Hello world";
std::cout <<"s 的长度是:"<< Stelen(s)< endl;
//调用自己编写的 Strlen()函数
std::cout <<"s 的长度是:"<< strlen(s)<< endl;
//调用标准库的 strlen()函数
}答：
#include <iostream>
#include <cstring>
using namespace std;
int Strlen(const char *str) {
int length = 0;
while (*str != '\0') {
length++;
str++;
}
return length;
}
int main() {
char *s = "Hello world";
// 调用自己编写的 Strlen() 函数
cout << "s 的长度是：" << Strlen(s) << endl;
// 调用标准库的 strlen() 函数
cout << "s 的长度是：" << strlen(s) << endl;
return 0;
}30.实现并测试简单选择排序算法。
答：
#include <iostream>
using namespace std;
void selectionSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
int min_idx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
// Swap the found minimum element with the first element
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}
int main() {
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);
cout << "原始数组为：" << endl;
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
selectionSort(arr, n);
cout << "排序后的数组为：" << endl;
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
return 0;
}31.完善学生成绩分析程序,用动态内存分配存储所有学生的多门成绩,并根据每门成绩占总成绩的百分比计算总评成绩,分析期末成绩或总评成绩的平均分,分距(最高分减去最低分),不同分数区间(不及格、及格、中等、良好,优秀)的百分比等。要求:学生的成绩、每门成绩占总成绩的百分比都从键盘输入。
答：
#include <iostream>
using namespace std;
// 结构体存储学生信息和成绩
struct Student {
string name;
int numScores;
double *scores;
};
// 计算总评成绩
double calculateTotalScore(const Student &student, const double *scorePercentages) {
double totalScore = 0.0;
for (int i = 0; i < student.numScores; i++) {
totalScore += student.scores[i] * scorePercentages[i];
}
return totalScore;
}
int main() {
int numStudents, numSubjects;
cout << "请输入学生人数: ";
cin >> numStudents;
cout << "请输入科目数: ";
cin >> numSubjects;
// 动态内存分配存储所有学生的多门成绩
Student *students = new Student[numStudents];
for (int i = 0; i < numStudents; i++) {
cout << "请输入第 " << i + 1 << " 个学生的姓名: ";
cin >> students[i].name;
students[i].numScores = numSubjects;
students[i].scores = new double[numSubjects];
cout << "请输入 " << students[i].name << " 的各科成绩: " << endl;
for (int j = 0; j < numSubjects; j++) {
cin >> students[i].scores[j];
}
}
// 接受每门成绩占总成绩的百分比
double *scorePercentages = new double[numSubjects];
cout << "请输入每门成绩占总成绩的百分比: " << endl;
for (int i = 0; i < numSubjects; i++) {
cout << "科目 " << i + 1 << " 的百分比: ";
cin >> scorePercentages[i];
}
// 计算总评成绩及其他相关统计信息
double totalTotalScore = 0.0;
double minTotalScore = 1000.0;
double maxTotalScore = 0.0;
int numPass = 0, numFail = 0, numMiddle = 0, numGood = 0, numExcellent = 0;
for (int i = 0; i < numStudents; i++) {
double totalScore = calculateTotalScore(students[i], scorePercentages);
totalTotalScore += totalScore;
if (totalScore < minTotalScore) {
minTotalScore = totalScore;
}
if (totalScore > maxTotalScore) {
maxTotalScore = totalScore;
}
if (totalScore < 60) {
numFail++;
} else if (totalScore >= 60 && totalScore < 70) {
numPass++;
} else if (totalScore >= 70 && totalScore < 80) {
numMiddle++;
} else if (totalScore >= 80 && totalScore < 90) {
numGood++;
} else {
numExcellent++;
}
}
// 输出统计信息
cout << "总评成绩的平均分: " << totalTotalScore / numStudents << endl;
cout << "分距: " << maxTotalScore - minTotalScore << endl;
cout << "不及格百分比: " << numFail * 100.0 / numStudents << "%" << endl;
cout << "及格百分比: " << numPass * 100.0 / numStudents << "%" << endl;
cout << "中等百分比: " << numMiddle * 100.0 / numStudents << "%" << endl;
cout << "良好百分比: " << numGood * 100.0 / numStudents << "%" << endl;
cout << "优秀百分比: " << numExcellent * 100.0 / numStudents << "%" << endl;
// 释放动态分配的内存
for (int i = 0; i < numStudents; i++) {
delete[] students[i].scores;
}
delete[] students;
delete[] scorePercentages;
return 0;
}32.用动态内存分配来表示二维矩阵,编写一个函数实现初始化一个矩阵、根据下标读写矩阵元素、两个矩阵相加或相乘、输出一个矩阵的功能。
答：
#include <iostream>
using namespace std;
// 定义矩阵类
class Matrix {
private:
int rows;
int cols;
int **data;
public:
// 构造函数
Matrix(int r, int c) {
rows = r;
cols = c;
// 动态分配内存
data = new int*[rows];
for (int i = 0; i < rows; ++i) {
data[i] = new int[cols];
}
}
// 析构函数
~Matrix() {
// 释放内存
for (int i = 0; i < rows; ++i) {
delete[] data[i];
}
delete[] data;
}
// 初始化矩阵
void initialize() {
cout << "Enter matrix elements:" << endl;
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
cin >> data[i][j];
}
}
}
// 读取矩阵元素
int getElement(int i, int j) {
return data[i][j];
}
// 设置矩阵元素
void setElement(int i, int j, int val) {
data[i][j] = val;
}
// 矩阵相加
Matrix add(Matrix& m) {
Matrix result(rows, cols);
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
result.data[i][j] = data[i][j] + m.data[i][j];
}
}
return result;
}
// 矩阵相乘
Matrix multiply(Matrix& m) {
Matrix result(rows, m.cols);
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < m.cols; ++j) {
result.data[i][j] = 0;
for (int k = 0; k < cols; ++k) {
result.data[i][j] += data[i][k] * m.data[k][j];
}
}
}
return result;
}
// 输出矩阵
void print() {
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
cout << data[i][j] << " ";
}
cout << endl;
}
}
};
int main() {
int rows, cols;
cout << "Enter number of rows and columns for matrix 1: ";
cin >> rows >> cols;
// 创建矩阵1
Matrix matrix1(rows, cols);
matrix1.initialize();
cout << "Enter number of rows and columns for matrix 2: ";
cin >> rows >> cols;
// 创建矩阵2
Matrix matrix2(rows, cols);
matrix2.initialize();
// 输出矩阵1
cout << "Matrix 1:" << endl;
matrix1.print();
// 输出矩阵2
cout << "Matrix 2:" << endl;
matrix2.print();
// 计算矩阵相加
Matrix sum = matrix1.add(matrix2);
cout << "Sum of matrices:" << endl;
sum.print();
// 计算矩阵相乘
Matrix product = matrix1.multiply(matrix2);
cout << "Product of matrices:" << endl;
product.print();
return 0;
}