实验一1
#include<iostream>
using namespace std; //该行代码表示使用了C++标准库的std命名空间，这样就可以直接使用std命名空间内的函数和对象，而不需要使用std::前缀。
int main() //定义了程序的主函数。
{
int arr[4]={1,2,3,4},i; //声明了一个包含4个整数的数组arr，并赋初值为{1, 2, 3, 4}。另外定义了一个整型变量i。
int *a=arr; //定义了一个整型指针a，指向数组arr的第一个元素的地址。
int *&p=a; //定义了一个整型指针p的引用，指向指针a。这里涉及到引用的概念，p的改变会影响a，反之亦然。
p++; //将指针p的值自增，使其指向数组arr的下一个元素。
*p=100; //将指针p所指向的值修改为100。
cout << *a <<"\t" <<*p <<endl; //输出指针a和指针p所指向的值，以及换行。
for (i=0;i<4;i++)
cout << arr[i] << "\t";//通过循环输出数组arr的所有元素。
cout << endl;
int b=10; //定义了一个整型变量b，赋值为10。
p=&b;//将指针p指向变量b的地址。
cout << *a <<"\t" <<*p <<endl; //输出指针a和指针p所指向的值，以及换行。
for(i=0;i<4;i++)
cout << arr[i] << "\t"; //通过循环输出数组arr的所有元素。
cout << endl;
return 0; //主函数执行完毕，返回0表示程序正常结束。
}
实验一2
#include<iostream> //包含iostream标准库头文件，以便使用输入输出流。
using namespace std; //使用std命名空间，避免每次使用标准库的函数时都需要写std::前缀。
void fun(int x, int& y)
{
x += y;
y += x;
} //定义了一个名为fun的函数，接受一个整型参数x和一个整型引用参数y。在函数体内，x与y相加并赋值给x，然后y再与x相加。
int main()
{
int x = 5, y = 10;
fun(x, y); //在主函数中，定义了两个整型变量x和y，分别赋值为5和10。调用fun函数，传入x和y的值，其中x和y的值会传递给函数fun。
fun(y, x); //再次调用fun函数，传入y和x的值，因为fun函数中的y是引用参数，在第一次调用时y的值已经被更改，所以会引起不同的结果。
cout << "x=" << x << ",y=" << y << endl; //输出变量x和y的值。
return 0; //返回0表示程序正常结束。
}
实验二1
头文件
#include<iostream>
#include<string> //包含iostream和string标准库的头文件，以便使用输入输出流和string类。
using namespace std;//使用std命名空间，避免每次使用标准库的函数时都需要写std::前缀。
class Croster
{
public:
static int Count;
private:
string name;
int Math;
int English;
int Sum;
public:
Croster(string na = "undef", int m = 10, int e = 100);
void Display();
int Cumulation();
}; //定义了一个名为Croster的类，包括公有成员变量Count（静态成员）、成员变量name、Math、English和Sum，以及公有成员函数Croster、Display和Cumulation。静态成员Count是类的静态成员变量，属于整个类，而不是类的具体对象。
Croster::Croster(string na = "undef", int m = 10, int e = 100)
{
name = na;
Math = m;
English = e;
Sum = Math + English;
} //Croster类的构造函数，带有默认参数值，用于初始化成员变量name、Math、English和Sum。
void Croster::Display()
{
cout << "Name: " << name << endl;
cout << "Math score: " << Math << endl;
cout << "English score: " << English << endl;
cout << "Total score: " << Sum << endl;
}//Croster类的成员函数Display，用于显示学生的姓名、数学成绩、英语成绩和总成绩。
int Croster::Cumulation()
{
return Math + English;
} //Croster类的成员函数Cumulation，用于计算学生的数学成绩和英语成绩之和，并返回结果。
2-1源文件1
#include"2-1头文件.h" //包含名为"2-1头文件"的头文件，这里假设该头文件中包含了Croster类的声明和相关依赖。
int Croster::Count = 100; //对Croster类的静态成员变量Count进行初始化，赋值为100。
Croster::Croster(string na, int m, int e) :name(na), Math(m), English(e)
{
cout << "欢迎新同学" << endl;
Sum = Math + English;
Count--;
} //Croster类的构造函数的另一种实现方式，采用了成员初始化列表来初始化成员变量name、Math、English。在构造函数中输出"欢迎新同学"，计算总成绩Sum，并将Count减1。
void Croster::Display()
{
cout << name << endl;
cout << "Math:" << Math << endl;
cout << "English:" << English << endl;
cout << "Sum:" << Sum << endl;
}//Croster类的成员函数Display，用于显示学生的姓名、数学成绩、英语成绩和总成绩。
int Croster::Cumulation()
{
Sum = Math + English;
return Sum;
} //Croster类的成员函数Cumulation，重新计算学生的数学成绩和英语成绩之和，并返回结果。
2-1源文件2
#include"2-1头文件。h"
包含名为"2-1头文件"的头文件，这里假设该头文件中包含了Croster类的声明和相关依赖。
int main()
{
cout << "Number of all student=" << Croster::Count << endl;
Croster list[3];
cout << "Number of all student=" << list[1].Count << endl;
Croster stu_A;
cout << "Number of all student=" << stu_A.Count << endl;
cout << "Number of all student=" << Croster::Count << endl;
return 0;
}
//定义了主函数main，依次执行以下操作：
1. 输出所有学生数目，即输出Croster类的静态成员变量Count的值。
1. 创建了一个Croster类的数组list，包含3个对象，输出第二个对象list[1]的Count值。
1. 创建了一个Croster对象stu_A，输出该对象的Count值。
1. 再次输出所有学生数目，即输出Croster类的静态成员变量Count的值。
这段代码演示了静态成员变量的使用方式，可以通过类名::静态成员变量名或对象名.静态成员变量名来访问静态成员变量，静态成员变量是属于整个类而不是类的对象的。
实验三
#include <iostream>
using namespace std;
class BaseA
{
private:
int a1;
protected:
int a2;
public:
int a3;
void setA(int x, int y, int z)
{
a1 = x;
a2 = y;
a3 = z;
}
void showA()
{
cout << "a1=" << a1;
cout << "a2=" << a2;
cout << "a3=" << a3 << endl;
}
};
class BaseB
{
private:
int b1;
protected:
int b2;
public:
int b3;
void setB(int x, int y, int z)
{
b1 = x;
b2 = y;
b3 = z;
}
void showB()
{
cout << "b1=" << b1;
cout << "b2=" << b2;
cout << "b3=" << b3 << endl;
}
};
class BaseC
{
private:
int c1;
protected:
int c2;
public:
int c3;
void setC(int x, int y, int z)
{
c1 = x;
c2 = y;
c3 = z;
}
void showC()
{
cout << "c1=" << c1;
cout << "c2=" << c2;
cout << "c3=" << c3 << endl;
}
};
class Derived : public BaseA, protected BaseB, private BaseC
{
private:
int d1;
protected:
int d2;
public:
int d3;
void setD(int x, int y, int z)
{
d1 = x;
d2 = y;
d3 = z;
}
void showD()
{
cout << "d1=" << d1;
cout << "d2=" << d2;
cout << "d3=" << d3 << endl;
}
void setall(int x0, int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8, int x9, int x10, int x11)
{
setA(x0, x1, x2);
setB(x3, x4, x5);
setC(x6, x7, x8);
setD(x9, x10, x11);
}
void showall()
{
showA();
showB();
showC();
showD();
}
};
int main()
{
Derived obj;
obj.setall(10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120);
//obj.showA();
//obj.showB();
//obj.showC();
//obj.showD();
obj.showall();
return 0;
}
#include <iostream>
using namespace std;
class Base
{
public:
Base(int x)
{
a = x;
}
virtual void Print()
{
cout << "Base::a=" << a << endl;
}
int a;
};
class Derived : public Base
{
public:
int a;
Derived(int x, int y) : Base(x)
{
a = y;
Base::a *= 2;
}
void Print()
{
Base::Print();
cout << "Derived::a=" << a << endl;
}
};
void f1(Base& obj)
{
obj.Print();
}
void f2(Derived& obj)
{
obj.Print();
}
int main()
{
Base b(9);
Derived d(200, 300);
d.Print();
d.a = 400;
d.Base::a = 500;
d.Base::Print();
Base* pb;
pb = &b;
pb->Print();
pb = &d;
pb->Print();
f1(b);
f1(d);
Derived* pd;
pd = &d;
pd->Print();
f2(d);
return 0;
}
