①.进一步加深对类和对象的理解;
②.掌握集中对象传递的使用方法;
③.掌握静态成员的概念和使用;
实验共分成三部分，分别为part a,part b,part c;
.h 文件
#include <iostream>;
using namespace std;
.cpp 文件
#include "homework5.h";
class Tr
{
public :
Tr(int n) //构造函数，i的初始值为n；
{
i = n;
}
void set_i(int n) //重新设置i的值；
{
i = n;
}
int get_i() //因为i是private类型的对象变量，所以在类外面调用时
{ //要用一个public类型的对象函数调用；
return i;
}
private:
int i;
};
void square_it1(Tr ob) //对象ob作为 square_it的形参；
{
ob.set_i(ob.get_i() * ob.get_i());
cout << "在函数square_it1中，形参对象ob的数据成员i的值为：" << ob.get_i();
cout<< endl;
}
int main()
{
Tr obj(10);
cout << "调用square_it1前，实参对象obj的数据成员i的值为：";
cout << obj.get_i()<<endl;
square_it1(obj);
cout << "调用square_it1后，实参对象obj的数据成员i的值为：";
cout << obj.get_i() << endl;
cout << endl;
return 0;
}
从结果可以看出，因为该方法是通过"传值调用"传递给函数的，是单向传递，只由实参传给形参，而不能由形参传回实参，因此函数中对对象的任何修改均不影响调用该函数的对象（实参）本身。
.h 文件
#include <iostream>;
using namespace std;
.cpp 文件
#include "homework5.h";
class Tr
{
public :
Tr(int n) //构造函数，i的初始值为n；
{
i = n;
}
void set_i(int n) //重新设置i的值；
{
i = n;
}
int get_i() //因为i是private类型的对象变量，所以在类外面调用时
{ //要用一个public类型的对象函数调用；
return i;
}
private:
int i;
};
void square_it2(Tr *ob) //对象指针ob作为 square_it的形参；
{
ob->set_i(ob->get_i() * ob->get_i());
cout << "在函数square_it2中，形参对象ob的数据成员i的值为：" << ob->get_i();
cout << endl;
}
int main()
{
Tr obj(10);
cout << "调用square_it2前，实参对象obj的数据成员i的值为：";
cout << obj.get_i() << endl;
square_it2(&obj);
cout << "调用square_it2后，实参对象obj的数据成员i的值为：";
cout << obj.get_i() << endl;
cout << endl;
return 0;
}
使用对象指针作为函数的参数可以实现"传址调用"，即在函数调用时使实参对象和形参对象指针变量指向同一内存地址，在函数调用过程中，对形参对象指针所指对象值的改变同样也会影响着实参对象的值。
.h 文件：
#include <iostream>;
using namespace std;
.cpp 文件：
#include "homework5.h";
class Tr
{
public :
Tr(int n) //构造函数，i的初始值为n；
{
i = n;
}
void set_i(int n) //重新设置i的值；
{
i = n;
}
int get_i() //因为i是private类型的对象变量，所以在类外面调用时
{ //要用一个public类型的对象函数调用；
return i;
}
private:
int i;
};
void square_it3(Tr& ob) //对象的引用ob作为 square_it的形参；
{
ob.set_i(ob.get_i() * ob.get_i());
cout << "在函数square_it3中，形参对象ob的数据成员i的值为：" << ob.get_i();
cout << endl;
}
int main()
{
Tr obj(10);
cout << "调用square_it3前，实参对象obj的数据成员i的值为：";
cout << obj.get_i() << endl;
square_it3(obj);
cout << "调用square_it3后，实参对象obj的数据成员i的值为：";
cout << obj.get_i() << endl;
cout << endl;
return 0;
}
使用对象引用作为函数参数可以达到使用对象指针的相同结果，而且使用对象引用更简单、更直接，因此使用更加普遍。
.h文件
#include <iostream>;
using namespace std;
.cpp文件
#include "homework5.h";
class Ctest
{
public :
Ctest()
{
count++;
cout << "对象数量为=" << count << '\n';
}
private :
static int count;
};
int Ctest::count = 0; //初始化静态成员变量
int main()
{
Ctest a[3]; //创建3个对象
return 0;
}
1.在定义静态变量时不能直接赋值：
原因：静态数据成员初始化应该在类外单独进行，而且应该在定义对象之前进行。一般在main之前。 相关文章：为什么static变量一定要在类外初始化?
但是我试了一下在对象之前进行，但是在main函数中，结果如下：
在main中但是在类定义之前初始化也不可以。
1.静态成员由关键字static修饰，为所有对象共享，只有一份存于公用内存中。
2.静态成员包括静态数据成员和静态函数成员。
3.该程序创建了三个对象，每创建一个对象静态int 变量 count就会加一，所以count为3。
4.静态数据成员初始化应在类外单独进行，并且在main之前。
.h 文件：
#include <iostream>;
using namespace std;
.cpp文件：
#include "homework5.h";
class Student
{
public:
void InitStudent(char name[]) //学生姓名初始化成员函数
{
cout << "学生姓名为:" << name;
}
void ExpendMoney(float money) //班费花销计算成员函数
{
cout << " 花费了" << money<<endl;
m_ClassMoney = m_ClassMoney - money;
}
void ShowMoney() //班费余额显示成员函数
{
cout << "班费还剩余" << m_ClassMoney<<endl;
}
private:
static float m_ClassMoney;
};
float Student::m_ClassMoney = 1000;
int main()
{
int i;
char name_a[10] = "A";
char name_b[10] = "B";
char name_c[10] = "C";
Student StudentA, StudentB, StudentC;
StudentA.InitStudent(name_a);
StudentA.ExpendMoney(50);
StudentA.ShowMoney();
StudentB.InitStudent(name_b);
StudentB.ExpendMoney(98.5);
StudentB.ShowMoney();
StudentC.InitStudent(name_c);
StudentC.ExpendMoney(500.53);
StudentC.ShowMoney();
return 0;
}
本次实验完成了传对象参数的三种不同方法，其中第一种无法修改对象中的内容，而而三种方法都可以修改对象中的内容，通过传递对象引用，可以方便的在传递的函数中修改对象中的成员变量，用起来十分方便。