2.6 第五章 静态成员与友元
1、一个类的头文件如下所示，num初始化值为5，程序产生对象T，且修改num为10，并使用show()函数输出num的值10。
#include
class Test
{ private:
static int num;
public:
Test(int);
void show();
};
int Test::num=5;
Test::Test(int n)
{ num=n; }
void Test::show()
{ cout<
void main()
{ Test t(10);
t.show();
}
解析：在类外初始化类内的成员时要加类名以及作用域限定符再进行初始化赋值，所以为int Test::num=5;程序产生对象T，且修改num为10在Test t(10);这句实现，使用show()函数输出num的值10：直接调用类里的show()函数即可，即t.show();
#include
using namespace std;
class Test
{
private:
static int num;
public:
Test(int);
void show();
};
int Test::num=5;//初始化num的值为5
Test::Test(int n)
{ num=n; }
void Test::show()
{
cout << num << endl;
}
int main()
{
Test t(10);
t.show();//输出最后num的值
return 0;
}
结果：
2 、在下面程序的底画线处填上适当的字句，使该程序执行结果为40。
#include
class Test
{ public:
static int x;
Test (int i=0)
{x=i+x;}
int Getnum()
{return Test::x+7;}
};
int Test::x=33;
void main()
{Test test;
cout<
}
解析：要想进行Test (int i=0)和int Getnum()函数的调用，则必须有一个成员变量x，要使该程序执行结果为40，需要确保Test类的成员变量x在全局范围内被初始化为某个值，然后在Test的构造函数中增加这个值，所以需要静态属性，所以成员变量x需为静态变量，即填static int x;然后再在全局初始化静态成员变量x，x+7后得到40，所有x应初始化为33，即int Test::x=33;
#include
using namespace std;
class Test
{
public:
static int x;//声明静态变量x
Test (int i=0)
{
x=i+x;
}
int Getnum()
{
return Test::x+7;
}
};
int Test::x=33;//初始化x的值为33
int main()
{
Test test;
cout< 结果：
3 、下列程序运行的结果是___________
#include
#include
#include
class student
{char name［8］;
int deg;
char level［7］;
friend class process; // 说明友元类
public:
student(char na［］,int d)
{ strcpy(name,na);
deg=d;
}
};
class process
{ public:
void trans(student &s)
{int i=s.deg/10;
switch(i)
{case 9:
strcpy(s.level, "优");break;
case 8:
strcpy(s.level,"良");break;
case 7:
strcpy(s.level,"中");break;
case 6:
strcpy(s.level,"及格");break;
default:
strcpy(s.level,"不及格");
}
}
void show(student &s)
{cout<
};
void main()
{ student st［］={student("张三",78),student("李四",92),student("王五
",62),student("孙六",88)};
process p;
cout<<"结 果:"<<"姓名"<
for(int i=0;i<4;i++)
{ p.trans(st［i］);
p.show(st［i］);}
}
解析：
#include
#include
#include
using namespace std;
class student
{
char name[8];
int deg;
char level[7];
friend class process; // 说明友元类
public:
student(char na[],int d)
{
strcpy(name,na);
deg=d;
}
};
class process
{
public:
void trans(student &s)
{
int i=s.deg/10;
switch(i)
{
case 9:strcpy(s.level, "优");break;
case 8:strcpy(s.level,"良");break;
case 7:strcpy(s.level,"中");break;
case 6:strcpy(s.level,"及格");break;
default:strcpy(s.level,"不及格");
}
}
void show(student &s)
{
cout< 结果：
二、编程题
1.
(1) 编写一个类，声明一个数据成员和一个静态数据成员。让构造函数初始化数据成员，并把静态数据成员加1，让析构函数把静态数据成员减1。
(2) 根据(1)编写一个应用程序，创建三个对象，然后显示它们的数据成员和静态数据成员，再析构每个对象，并显示它们对静态数据成员的影响。
(3) 修改(2)，让静态成员函数访问静态数据成员，并让静态数据成员是保户的。
解析：（1）代码：
#include
using namespace std;
class MyClass
{
private:
int member; //数据成员
static int staticmember; //静态数据成员
public:
//静态成员初始化
static int staticmemberCounter;
//无参构造函数
MyClass()
{
member=0; //初始化数据成员
staticmemberCounter++; //静态数据成员加1
staticmember=staticmemberCounter;
cout << "staticmember: " << staticmember << endl;
}
//有参构造函数
MyClass(int m)
{
member=m; //初始化数据成员
staticmemberCounter++; //静态数据成员加1
staticmember = staticmemberCounter;
cout << "staticmember: " << staticmember << endl;
}
//析构函数
~MyClass()
{
staticmemberCounter--; //静态数据成员减1
cout << "staticmember: " << staticmember << endl;
}
//成员函数，用于显示数据成员和静态数据成员
void show()
{
cout << "member: " << member << ", staticmember: " << staticmember << endl;
}
};
//静态成员初始化
int MyClass::staticmemberCounter = 0;
int MyClass::staticmember = 0;
int main()
{
MyClass mc1;
mc1.show();
MyClass mc2(1);
mc2.show();
return 0;
}
结果：
（2）代码：
#include
using namespace std;
class MyClass
{
private:
int member; //数据成员
static int staticmember; //静态数据成员
public:
//静态成员初始化
static int staticmemberCounter;
//无参构造函数
MyClass()
{
member=0; //初始化数据成员
staticmemberCounter++; //静态数据成员加1
staticmember=staticmemberCounter;
cout << "staticmember: " << staticmember << endl;
}
//有参构造函数
MyClass(int m)
{
member=m; //初始化数据成员
staticmemberCounter++; //静态数据成员加1
staticmember = staticmemberCounter;
cout << "staticmember: " << staticmember << endl;
}
//析构函数
~MyClass()
{
staticmemberCounter--; //静态数据成员减1
cout << "staticmember: " << staticmember << endl;
}
//成员函数，用于显示数据成员和静态数据成员
void show()
{
cout << "member: " << member << ", staticmember: " << staticmember << endl;
}
};
//静态成员初始化
int MyClass::staticmemberCounter = 0;
int MyClass::staticmember = 0;
int main()
{
MyClass mc1;//创建第一个对象
mc1.show();//显示数据成员和静态数据成员
MyClass mc2;//创建第二个对象
mc2.show();//显示数据成员和静态数据成员
MyClass mc3;//创建第三个对象
mc3.show();//显示数据成员和静态数据成员
// 析构每个对象
mc1.~MyClass();
mc2.~MyClass();
mc3.~MyClass();
return 0;
}
结果：
（3）代码：
#include
using namespace std;
class MyClass
{
private:
int member; //数据成员
protected:
static int staticmember; //静态数据成员
public:
//静态成员初始化
static int staticmemberCounter;
//无参构造函数
MyClass()
{
member=0; //初始化数据成员
staticmemberCounter++; //静态数据成员加1
staticmember=staticmemberCounter;
cout << "staticmember: " << staticmember << endl;
}
//有参构造函数
MyClass(int m)
{
member=m; //初始化数据成员
staticmemberCounter++; //静态数据成员加1
staticmember = staticmemberCounter;
cout << "staticmember: " << staticmember << endl;
}
//析构函数
~MyClass()
{
staticmemberCounter--; //静态数据成员减1
cout << "staticmember: " << staticmember << endl;
}
//成员函数，用于显示数据成员和静态数据成员
void show()
{
cout << "member: " << member << ", staticmember: " << staticmember << endl;
}
//静态成员函数，用于显示静态数据成员
static void staticmembershow()
{
cout << "protected staticmember: " << staticmember << endl;
}
};
//静态成员初始化
int MyClass::staticmemberCounter = 0;
int MyClass::staticmember = 0;
int main()
{
MyClass mc1;//创建第一个对象
mc1.show();//显示数据成员和静态数据成员
mc1.staticmembershow();//使用静态成员函数显示静态数据成员
MyClass mc2;//创建第二个对象
mc2.show();//显示数据成员和静态数据成员
mc2.staticmembershow();//使用静态成员函数显示静态数据成员
MyClass mc3;//创建第三个对象
mc3.show();//显示数据成员和静态数据成员
mc3.staticmembershow();//使用静态成员函数显示静态数据成员
// 析构每个对象
mc1.~MyClass();
mc2.~MyClass();
mc3.~MyClass();
return 0;
}
结果：
2.
(1) 下述代码有何错误，改正它。
| #include < iostream> using namespace std; class Animal; void SetValue(Animal&, int); void SetValue(Animal&, int, int); class Animal { public: friend void SetValue(Animal&, int); protected: int itsWeight; int itsAge; }; void SetValue(Animal& ta, int tw) { a.itsWeight = tw; } void SetValue(Animal& ta, int tw, int tn) { ta.itsWeight = tw; ta.itsAge = tn; } int main() { Animal peppy; SetValue(peppy, 5); SetValue(peppy, 7,9); return 0; } 解析 a.itsWeight = tw;对象名不完整 改为ta.itsWeight = tw; void SetValue(Animal& ta, int tw, int tn)这个函数不是友元，无法在类外访问受保护的成员变量，应在 friend void SetValue(Animal&, int);后加一句friend void SetValue(Animal&, int, int); |
#include
using namespace std;
class Animal;
void SetValue(Animal&,int);
void SetValue(Animal&,int,int);
class Animal
{
public:
friend void SetValue(Animal&,int);
friend void SetValue(Animal&,int,int);
protected:
int itsWeight;
int itsAge;
};
void SetValue(Animal&ta, int tw)
{
ta.itsWeight=tw;
}
void SetValue(Animal&ta,int tw,int tn)
{
ta.itsWeight = tw;
ta.itsAge = tn;
}
int main()
{
Animal peppy;
SetValue(peppy, 5);
SetValue(peppy, 7,9);
return 0;
} (2) 将上面程序中的友员改成普通函数，为此增加访问类中保护数据的成员函数。
代码：
#include
using namespace std;
class Animal
{
public:
void SetWeight(int weight)
{
itsWeight=weight;
}
void SetAge(int age)
{
itsAge=age;
}
protected:
int itsWeight;
int itsAge;
};
void SetValue(Animal&ta,int tw)
{
ta.SetWeight(tw);
}
void SetValue(Animal&ta,int tw,int tn)
{
ta.SetWeight(tw);
ta.SetAge(tn);
}
int main()
{
Animal peppy;
SetValue(peppy, 5);
SetValue(peppy, 7, 9);
return 0;
} 3. 重新编写下述程序，使函数Leisure()成为类Car和类Boat的函数。作为重新编程，在类Car和类Boat中，增加函数set()。
| #include < iostream> using namespace std; class Boat; class Car { public: Car(int j){size = j;} friend int Leisure(int time, Car& aobj, Boat& bobi); protected: int size; class Boat { public: Boat(int j){size = j;} friend int Leisure(int time, Car& aobj, Boat& bobj); protected: int size; }; int Leisure(int time, Car& aobj, Boat& bobi) { return time * aobj.size *bobi.size; } ｝; int main() { Car c1(2); Boat bl(3); int time = 4; cout << Leisure(time, cl,bl); return 0; } |
#include
using namespace std;
class Boat;
class Car
{
friend class Boat;
public:
Car(int j):size(j){}//初始化列表用于初始化成员变量
// Leisure函数作为Car类的成员函数
int Leisure(int time,Boat &b)const
{
return time*size*b.size;
}
//设置size的函数
void set(int newSize)
{
size=newSize;
}
protected:
int size;
};
class Boat
{
public:
Boat(int j):size(j){}//初始化列表用于初始化成员变量
// Leisure函数作为Boat类的成员函数
int Leisure(int time,Car &a)const
{
return time*a.size*size;
}
//设置size的函数
void set(int newSize)
{
size=newSize;
}
protected:
int size;
};
int main()
{
Car c1(2);
Boat b1(3);
int time=4;
//使用Car类的Leisure函数
cout << c1.Leisure(time, b1) << endl;
// 使用Boat类的Leisure函数
cout << b1.Leisure(time, c1) << endl;
return 0;
}
结果：