2.6 第五章 静态成员与友元

最新推荐文章于 2024-11-04 19:24:37 发布
最新推荐文章于 2024-11-04 19:24:37 发布
阅读量885 收藏 15
点赞数 24
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80922669/article/details/136051323
版权
、填空题

1、一个类的头文件如下所示，num初始化值为5，程序产生对象T，且修改num为10，并使用show()函数输出num的值10。

#include <iostream.h>

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<<num<<endl; }

void main()

{ Test t(10);

t.show();

}

解析：在类外初始化类内的成员时要加类名以及作用域限定符再进行初始化赋值，所以为int Test::num=5;程序产生对象T，且修改num为10在Test t(10);这句实现，使用show()函数输出num的值10：直接调用类里的show()函数即可，即t.show();

#include <iostream>
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 <iostream>

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.Getnum()<<endl;;

}

解析：要想进行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 <iostream>
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<<test.Getnum()<<endl;
    return 0;
}

结果：

3 、下列程序运行的结果是___________

     #include <iostream.h>

#include <string.h>

#include <iomanip.h>

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<<setw(10)<<s.name<<setw(4)<<s.deg<<setw(8)<<s.level<<endl;}

};

void main()

{ student st［］={student("张三",78),student("李四",92),student("王五

",62),student("孙六",88)};

process p;

cout<<"结 果:"<<"姓名"<<setw(6)<<"成绩"<<setw(8)<<"等级"<<endl;

for(int i=0;i<4;i++)

{ p.trans(st［i］);

p.show(st［i］);}

}

解析：

#include <iostream>
#include <string.h>
#include <iomanip>
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<<setw(10)<<s.name<<setw(4)<<s.deg<<setw(8)<<s.level<<endl;
    }
};
int main()
{
    student st[]={student("张三",78),student("李四",92),student("王五",62),student("孙六",88)};
    process p;
    cout<<"结 果:"<<"姓名"<<setw(6)<<"成绩"<<setw(8)<<"等级"<<endl;
    for(int i=0;i<4;i++)
    {
        p.trans(st[i]);
        p.show(st[i]);
    }
}

结果：

二、编程题

1.

 (1) 编写一个类，声明一个数据成员和一个静态数据成员。让构造函数初始化数据成员，并把静态数据成员加1，让析构函数把静态数据成员减1。

 (2) 根据(1)编写一个应用程序，创建三个对象，然后显示它们的数据成员和静态数据成员，再析构每个对象，并显示它们对静态数据成员的影响。

 (3) 修改(2)，让静态成员函数访问静态数据成员，并让静态数据成员是保户的。

解析：（1）代码：

#include <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>  
  
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 <iostream>

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;
}

结果：

‮⠀
关注
【C++】第二章：CC++类与对象
Roger_717的博客
11-08 598
目录 2.1 类 2.2 成员函数 2.3 常量成员函数 2.4 类与封装 2.5 对象 2.5.1 对象的定义 2.5.2 对象的引用 2.5.3对象的赋值 2.6 构造函数 2.6.1 无参构造函数（默认构造函数） 2.7 析构函数 2.8 函数的重载 2.9 静态成员 2.9.1 静态成员的声明及定义 2.9.2静态成员的定义： 2.9.3 静态成员的访问 2.10 this指针 2.10.1 this指针的概念 2.11 友元 类与对象是实现数据封装和信息.
C++ Primer 第十六章 模板与泛型编程 重点解读
Dusong_的博客
11-30 1094
重点解读c++11模板与泛型编程特性，以及C++20concept特性
第二章：类和对象（下）
weixin_63716012的博客
03-17 762
构造函数的初始化方式，初始化列表，隐式类型转换，匿名对象，static修饰的静态成员，友元，内部类，连续构造和拷贝构造时编译器的一些优化
【C++修炼之路 第二章：类和对象 】中：类的 6个默认成员函数
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-15 947
【思考细节】【细致讲解类的 6 个默认成员函数】构造、析构、拷贝构造、赋值重载、取地址& 和 const 取地址操作符重载
《C++Primer》第十六章 模板与泛型编程
TOMACAT的博客
11-21 668
第十六章 模板与泛型编程 定义模板 1. 函数模板 模板定义以关键字template关键字开始，后面跟着一个模板参数列表(不能为空)： template <typename T> int compare(const T &v1, const T &v2) { if (v1 < v2) return -1; if (v2 < v1) retur...
【C++基础】第11章：类
qq_60225495的博客
11-14 2722
类1 结构体与对象聚合1.1 结构体1.1.1 结构体的声明与定义（注意定义后面要跟分号来表示结束）1.1.2 仅有声明的结构体是不完全类型（ incomplete type ）1.1.3 结构体（以及类）的一处定义原则：翻译单元级别1.2 数据成员（数据域）的声明与初始化1.2.1 （ C++11 ）数据成员可以使用 decltype 来声明其类型，但不能使用 auto1.2.2 数据成员声明时可以引入 const 、引用等限定1.2.3 数据成员会在构造类对象时定义1.2.4 （ C++11 ）类内成
第二章 C++类和对象
qq_40632679的博客
03-04 632
2.1 C++类的定义和对象的创建 类的定义 只是一种复杂数据类型的声明，编译后不占用内存空间 定义类时不能对成员变量进行初始化 用类创建对象 class 关键字可省略 class Student LiLei; //正确 Student LiLei; //同样正确 访问类的成员 栈上创建的对象 Stu stu; 有名字，可以用点号来访问成员变量和成员函数 堆上创建的对象（new） 没有名字，借
C++ Primer, Fifth Edition - 下载电子书与源代码
既然选择了远方 便只顾风雨兼程 - 永强
07-29 3106
C++ Primer, Fifth Edition - 下载电子书与源代码
【C++修炼之路 第二章：类和对象 】下
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-16 1377
【面试知识点】【OJ例题】初始化列表 + 自定义类型的隐式类型转换 + static成员 + 友元函数友元类 + 匿名对象
C++ Primer中文版（第5版）李普曼 等著 pdf 1/3
02-24
　第5章 语句 153 　5.1 简单语句 154 　5.2 语句作用域 155 　5.3 条件语句 156 　5.3.1 if语句 156 　5.3.2 switch语句 159 　5.4 迭代语句 165 　5.4.1 while语句 165 　5.4.2 传统的for语句 166 　5.4.3 范围for...
-C++参考大全(第四版) (2010 年度畅销榜
12-08
第5章 指针 5.1 什么是指针 5.2 指针变量 5.3 指针运算符 5.4 指针表达式 5.5 指针和数组 5.6 多级间址 5.7 初始化指针 5.8 指向函数的指针 5.9 C语言的动态分配函数 5.10 指针应用中的问题 第6章 函数 6.1 函数的...
C++Primer(第5版 )中文版（美）李普曼等著.part2.rar
02-24
　第5章 语句 153 　5.1 简单语句 154 　5.2 语句作用域 155 　5.3 条件语句 156 　5.3.1 if语句 156 　5.3.2 switch语句 159 　5.4 迭代语句 165 　5.4.1 while语句 165 　5.4.2 传统的for语句 166 　5.4.3 范围for...
一小时复习完C++Primer！！！
专注游戏研发
05-30 1899
C++Primer全篇总结C++Primer 的了解C++11的新特性 C++Primer 的了解 C++Primer是基于 C++11标准进行编写的书籍，以 3 位作者 Standley B. Lippman,Josee Lajoie ,Barbara E.Moo在C++语言发展历程中的经历，这本书的权威性自不容置疑的：既有编译器的开发和实践，又参与 C++标准的制定，再加上丰富的 C++ 教学经历。该书是一本由浅入深的教程，同时考虑到该书的全面性，我们也可以当其为教材，以备随时查阅。 C++11的新特性
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 253
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 590
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++之指针和引用
weixin_42300449的博客
11-04 139
在C++中，指针和引用是两种不同的机制，它们都可以用来间接访问变量。
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 192
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
c++之 stack(栈)和queue(队列)
2301_80028974的博客
11-04 621
文档stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。
算法|牛客网华为机试31-40C++
最新发布
奇树谦的博客
11-04 486
计算第5次落地后球经过的距离，除了第一次只经过一次，所以距离最后在减去初始长度，高度每次减去一半。for循环遍历一次，从后往前，如果是字符组成单词等遇到空格或者非字母输出。直接用sort函数就是按着ASCII码从小到大排序的。找每行每列的相加差1的数学规律，再每行输出。
C++课件：静态成员与友元函数详解
总结起来，本节内容涵盖了C++中的关键概念，包括静态局部变量、静态全局变量、类的静态成员及其与非静态成员的区别，以及友元的作用和使用注意事项。这对于理解和设计高效、可维护的C++程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值