C++程序设计 练习题2

已于 2024-03-27 19:53:15 修改
阅读量315 收藏 1
点赞数 10
分类专栏： C++从入门到入门 文章标签： 开发语言 c++ 学习
于 2024-03-27 19:52:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43010742/article/details/137087369
版权

1. 类中的构造函数和析构函数可以重载吗？说明原因。

        构造函数可以，因为可以改变参数个数和类型，符合函数重载的要求；

        析构函数不可以，因为参数只有一个固定类型的this，故不可能重载；

2. 分析下面程序的运行结果。

class A {
    int a;
public:
    A(int a): a(a) { printf("A%d",a); }
    A(): a(0) { printf("A%d",a); }
    ~A() { printf("~A%d",a); }
} a(1);

class B {
    int b;
    A a1,a2;
public:
    B(int b): a1(2),b(b) { printf("B%d",b); }
    ~B() { printf("~B%d",b); }
} b(9);

int main() { }

输出：A1A2A0B9~B9~A0~A2~A1

3. 下面的类将N进制整数字符串s转换为M进制的字符串，请完成各个成员函数。测试程序为：

int main() { NumString s("A4",16); printf("%s %s", s.toString(10), s.toString(2)); }
class NumString {
	const char *s;	    //s[]为N进制整数字符串(字母都是大写),如"9AB6"(N=16)
	const int N;		//2 <= N <= 16
	int  decNum; 	//在构造函数中,将s[]转换为10进制数保存到该变量
public:
	NumString(const char *s, int N=10);  //构造函数, s[]是N进制整数字符串,含有大小写字母
	~NumString( );	  //析构函数
	char *toString(int M); //将s[]中的N进制字符串转换为M进制字符串,返回M进制字符串的首地址
private:
	void toNum( );  //将s[]中的N进制整数字符串转换为10进制数并保存到decNum
};

解答：

#include <cmath>
#include <cstdio>
class NumString {
    const char* s;     // s[]为N进制整数字符串(字母都是大写),如"9AB6"(N=16)
    const int N;       // 2 <= N <= 16
    int decNum;        // 在构造函数中,将s[]转换为10进制数保存到该变量

public:
    NumString(const char* s, int N = 10);  // 构造函数, s[]是N进制整数字符串,含有大小写字母
    ~NumString();                             // 析构函数
    char* toString(int M);                   // 将s[]中的N进制字符串转换为M进制字符串,返回M进制字符串的首地址

private:
    void toNum();  // 将s[]中的N进制整数字符串转换为10进制数并保存到decNum
};

NumString::NumString(const char* s, int N) : s(s), N(N) {
    toNum();
}

NumString::~NumString() {
}

char* NumString::toString(int M) {
    int maxLen =(int) (log(decNum) / log(M)) + 2;
    char* result = new char[maxLen];

    int quot = decNum;
    int i = 0;

    while (quot > 0) {
        int remainder = quot % M;
        result[i++] = (remainder < 10) ? remainder + '0' : remainder - 10 + 'A';
        quot /= M;
    }
    
    if (i == 0) {
        result[i++] = '0';
    }
    
    for (int j = 0; j < i / 2; j++) {
        char tmp = result[j];
        result[j] = result[i - j - 1];
        result[i - j - 1] = tmp;
    }

    result[i] = '\0';

    return result;
}

void NumString::toNum() {
    decNum = 0;
    int i = 0;
    //printf("%s\n", s);
    //printf("%d\n", N);
    while (s[i]) {
        int digit = 0;
        if (s[i] >= '0' && s[i] <= '9') {
            digit = s[i] - '0';
        }
        else if (s[i] >= 'A' && s[i] <= 'F') {
            digit = s[i] - 'A' + 10;
        }
        else if (s[i] >= 'a' && s[i] <= 'f') {
            digit = s[i] - 'a' + 10;
        }

        decNum = decNum * N + digit;
        //printf("%c %d %d\n", s[i], digit, decNum);
        i++;
    }
    
}

int main() {
    NumString s("A4", 16);
    printf("%s %s", s.toString(10), s.toString(2));

    return 0;
}

4. 集合类的头文件set.h如下，请定义其中的函数成员。

class SET { 
    int *set; 			//set用于存放集合元素 
    int card; 			//card为能够存放的元素个数 
    int used; 			//used为已经存放的元素个数
    public:
    SET(int card); 		//card为能够存放的元素个数 
    ~SET( );
    int size( ); 			//返回集合已经存放的元素个数 
    int insert(int v); 		//插入v成功时返回1，否则返回0 
    int remove(int v); 	//删除v成功时返回1，否则返回0 
    int has(int v); 		//元素v存在时返回1，否则返回0 
}；

解答：

#include<cstdio>

class SET {
        int* set;                         //set用于存放集合元素 
        int card;                         //card为能够存放的元素个数 
        int used;                         //used为已经存放的元素个数
public:
        SET(int card);                 //card为能够存放的元素个数 
        ~SET();
        int size();                         //返回集合已经存放的元素个数 
        int insert(int v);                 //插入v成功时返回1，否则返回0 
        int remove(int v);         //删除v成功时返回1，否则返回0 
        int has(int v);                 //元素v存在时返回1，否则返回0 
        //测试
        void printset();
};

SET::SET(int card) :card(card),used(0) {
        set = new int[card];
}

SET::~SET() {
        delete []set;
}

int SET::size() {
        return used;
}

int SET::insert(int v) {
        if (used == card) {
                return 0;
        }
        if (has(v)) {
                return 0;
        }
        set[used++] = v;
        return 1;
}

int SET::remove(int v) {
        if(used == 0) return 0;
        for (int i = 0; i < used; i++) {
                if (set[i] == v) {
                        set[i] = set[used - 1];
                        used--;
                        return 1;
                }
        }
        return 0;
}

int SET::has(int v) {
        for (int i = 0; i < used; i++) {
                if (set[i] == v) {
                        return 1;
                }
        }
        return 0;
}

void SET::printset() {
        printf("{");
        for (int i = 0; i < used - 1; i++) {
                printf("%d ", set[i]);
        }
        printf("%d", set[used - 1 ]);
        printf("}\n");
}

int main() {
        SET mySet(3);
        mySet.insert(1);
        mySet.printset();
        mySet.insert(1);
        mySet.printset();
        mySet.insert(2);
        mySet.printset();
        mySet.insert(3);
        mySet.printset();
        mySet.insert(4);
        mySet.printset();
        printf("%d \n", mySet.has(3));
}

5. 线性表通常提供元素查找、插入和删除等功能。以下线性表是一个整型线性表，表元素存放在动态申请的内存中，请编程定义整型线性表的函数成员。

class INTLIST { 
    int  *list; 			//动态申请的内存的指针 
    int  size; 			//线性表能够存放的元素个数 
    int  used; 			//线性表已经存放的元素个数
    public: 
    INTLIST(int s); 		//s为线性表能够存放的元素个数 
    int insert(int v); 		//插入元素v成功时返回1，否则返回0 
    int remove(int v); 	//删除元素v成功时返回1，否则返回0 
    int find(int v); 		//查找元素v成功时返回1，否则返回0 
    int get(int k); 		//取表的第k个元素的值作为返回值
    ~INTLIST( ); 
};

解答：

#include<cstdio>

class INTLIST {
        int* list;                         //动态申请的内存的指针 
        int  size;                         //线性表能够存放的元素个数 
        int  used;                         //线性表已经存放的元素个数
public:
        INTLIST(int s);                 //s为线性表能够存放的元素个数 
        int insert(int v);                 //插入元素v成功时返回1，否则返回0 
        int remove(int v);         //删除元素v成功时返回1，否则返回0 
        int find(int v);                 //查找元素v成功时返回1，否则返回0 
        int get(int k);                 //取表的第k个元素的值作为返回值
        void printlist();
        ~INTLIST();
};

INTLIST::INTLIST(int s) : size(s),used(0){
        list = new int [size];
}

INTLIST::~INTLIST() {
        delete [] list;
}

int INTLIST::insert(int v) {
        if (used == size) {
                return 0;
        }
        list[used++] = v;
        return 1;
}

int INTLIST::remove(int v) {
        for (int i = 0; i < used; i++) {
                if (list[i] == v) {
                        for (int j = i; j < used - 1; j++) {
                                list[j] = list[j + 1];
                        }
                        used--;
                        return 1;
                }
        }
        return 0;
}

int INTLIST::find(int v) {
        for (int i = 0; i < used; i++) {
                if (list[i] == v) {
                        return 1;
                }
        }
        return 0;
}

int INTLIST::get(int k) {
        if (k - 1 >= used || k - 1 < 0) {
                printf("wrong index\n");
                return -1;
        }
        return list[k - 1];
}

void INTLIST::printlist() {
        for (int i = 0; i < used - 1; i++) {
                printf("%d ", list[i]);
        }
        printf("%d\n", list[used - 1]);
}


int main() {
        INTLIST mylist(4);
        mylist.insert(1);
        mylist.insert(2);
        mylist.insert(1);
        mylist.insert(3);
        mylist.printlist();
        printf("at 2 is %d\n", mylist.get(2));
        mylist.remove(3);
        mylist.printlist();
        return 0;
}

6. 下面是二叉树类的定义，请完成各个成员函数。

class TREE { 
    int  item; //节点的值
    TREE  *left, *right; //左、右子树
    public:
    TREE(int item); //构造树：item为根节点、左右子树为null
    TREE(int item, TREE *left, TREE *right); //构造树：item为根节点、左右子树为left、right
    ~TREE( ); 
    int  getNodeNum( );	//返回节点总数
    int  getNodes(int items[ ]); //将所有的节点的值保存到items[ ]中
};

解答：

#include<cstdio>

class TREE {
        int  item; //节点的值
        TREE* left, * right; //左、右子树
public:
        TREE(int item); //构造树：item为根节点、左右子树为null
        TREE(int item, TREE* left, TREE* right); //构造树：item为根节点、左右子树为left、right
        ~TREE();
        int  getNodeNum();        //返回节点总数
        int getNodeshelper(int items[], int index);
        int  getNodes(int items[]); //将所有的节点的值保存到items[ ]中
};

TREE::TREE(int item) :item(item) {
        left = nullptr;
        right = nullptr;
}

TREE::TREE(int item, TREE* left, TREE* right) :item(item), left(left),right(right){

}

TREE::~TREE() {
        delete left;
        delete right;
}



int TREE::getNodeNum() {
        int nodenum = 1;
        if (left != nullptr) {
                nodenum += left->getNodeNum();
        }
        if (right != nullptr) {
                nodenum += right->getNodeNum();
        }
        return nodenum ;
}

int TREE::getNodes(int items[]) {
        getNodeshelper(items, 0);
        return 1;
}

int TREE::getNodeshelper(int items[], int index) {
        items[index++] = item;
        if (left != nullptr) {
                index = left->getNodeshelper(items, index);
        }
        if (right != nullptr) {
                index = right->getNodeshelper(items, index);
        }
        return index;
}


int main() {
        TREE* leaf1 = new TREE(12);
        TREE* leaf2 = new TREE(81);
        TREE* leaf3 = new TREE(92);
        TREE* leaf4 = new TREE(66);
        TREE* node1 = new TREE(1, leaf1, leaf2);
        TREE* node2 = new TREE(2, leaf3, leaf4);
        TREE* root = new TREE(4, node1, node2);

        int nodeCount = root->getNodeNum();
        printf("nodenum : %d\n", nodeCount);

        int *items = new int [nodeCount];
        root->getNodes(items);

        printf("Nodes: \n");
        for (int i = 0; i < nodeCount; i++) {
                printf("%d ", items[i]);
        }

        delete root;  

        return 0;
}

Sanchez·J
关注
  • 10
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
西北工业大学 C++程序设计 noj习题答案
10-19
该资源为西工大C++程序设计课程对应的noj习题答案， 总共150题，涵盖了所有题目， 按照题目名字首字母排序，并带有目录， 可作为noj的参考学习资料，希望大家都能ac。 适合人群：正在学习或已经学习过西工大C++程序...
C++程序设计练习题.doc
06-20
C++程序设计练习题 1. 编写一函数，对int型数组元素由小到大排序。 2．设计一个描述正方形的类，名为Square。该类包含一个私有数据成员为double类型的 L，用来表示正方形边长；包含一个构造函数将L初始化为给定值；...
C++程序设计练习题 Online Judge判定
06-07
此处的“平均值”定义为，若n>2，则需去掉一个最大值、一个最小值，剩下的n-2个数据的算术平均值；若n为1或2，则为普通的算术平均值。 输入 输入数据有多行，每一行上有若干个实数，对应一种情形（数据之间用一个...
最新C++程序设计综合练习题-读程序写结果题(20211215104928).pdf
11-16
最新C++程序设计综合练习题-读程序写结果题(20211215104928).pdf
C++面向对象程序设计习题集
05-04
C++面向对象程序设计习题集，主要练习面向对象思想。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Python知识点17---包
别人笑我太疯癫，我笑他人看不穿。
06-01 1371
Python的包，你可以把它看成是一个大的模块，它的本质是一个文件夹，所有有联系的模块都可以单独打成一个包，且在包生成的时候，包中会生成一个名字叫__init__.py的文件，这个文件规定了其他模块导入这个包时的导入行为 那么如何建立包呢？你如果使用的是PyCharm，你可以根据下面的步骤进行创建 1、在项目空白处，右键单击new--》Python Package 2、输入名字 3、点击OK之后，创建成功，并自动生成__init__文件 之后你就可以在包下如往常一样写代码了，当你要在其他模块中导入这
C语言中指针的说明
ZWW_zhangww的博客
06-05 1080
在C语言当中，我们可以将指针理解为内存当中存储的地址，就像生活当中，一个小区里面，在小区里面有很单元，每一栋单元，单元内的房间有着不同的房间号，我们可以同过几栋几单元去寻找我们想要找到的房间，同样的，我们在C语言当中，指针就是我们寻找想要的房间的一种手段。
C语言编译与链接
N201871643的博客
06-05 158
6.1 编写可移植的代码考虑到不同的操作系统和硬件可能需要不同的库文件，编写易于移植的代码是非常重要的。避免硬编码路径和使用跨平台兼容的库可以大大提高程序的可移植性。6.2 使用工具和脚本自动化构建过程使用像Make这样的构建工具可以帮助自动化编译和链接过程，使得在开发大型项目时更加高效。
【C语言从入门到入土】第六章 指针(下)
v13111329954的博客
06-08 659
本文主要介绍了指针偏移，通过指针引用数组，指针数组，数组指针，函数指针，指针函数，二级指针
C++|哈希结构封装unordered_set和unordered_map
最新发布
weixin_68201503的博客
06-11 575
上一篇章，学习了unordered系列容器的使用，以及哈希结构，那么这一篇章将通过哈希结构来封装unordered系列容器，来进一步的学习他们的使用以及理解为何是如此使用。其实，哈希表的封装方式和红黑树的封装方式形式上是差不多的，如果有了红黑树的封装理解经验，我相信在理解哈希封装的过程会减少负担的。当然，在使用哈希结构中采用的是更具代表的哈希桶，接下来进行封装。
c++ - 模板(二)
2302_79539362的博客
06-05 957
TYPE是类型按道理来说没有问题，但是编译器在检查到这里是就会出现歧义，不知道TYPE是类型还是静态变量，所以就会报错。给模板初始值与给函数初始值类似，当需要给一部分缺省值时，参数缺省值必须从右向左给，中间不能留着参数不给缺省值。非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。另一种解决方法就是直接写一个该类型的函数，这个函数会与模板函数构成重载，并且符合的话会被优先使用。在没有被实例化时，编译器只会对函数进行语法等检查，不会查看类内部细节，如上面的。
C++中的左值和右值
weixin_47987343的博客
06-04 243
左值通常与变量和持久数据关联。右值通常与临时数据和表达式的结果关联。右值引用提供了一种操作右值并优化资源管理和性能的方式。
mkfs.ubifs -c 计算工具
chengf223的博客
06-05 167
mkfs.ubifs -c 输入的logical erase block count,是指除掉ubi文件系统自身管理和坏块处理后的逻辑可擦除最大块数。
STL中stack和queue模拟实现+容器适配器
2202_75331338的博客
06-06 857
deque（双端队列）：是一种双开口的“连续”空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素，与list比较，空间利用率比较高。deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组双端队列底层是一段假象的连续的空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在看deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示；
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
KK爱Coding的博客
06-11 220
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
c++ namespace以及使用建议
weixin_68026222的博客
06-08 343
下面，我们自定义两个命名空间，然后对齐都进行using，内部包含一个同名函数，当我们去调用getAge()的时候会报错，因为，你同时using的两个命名空间中都有这个函数，编译器不知道用哪个，这就是。当然，将using namespace放到头文件中那更是不行的，因为头文件会到处包含，包含其的文件中可能也存在using namespace，这时候很容易出现下面的问题。在写c++代码的时候，经常会使用标准库中的函数，使用之前我们必须在前面添加一个std::，因为c++标准库的函数是在命名空间std下定义的。
深度搜索算法3（c++）
mmz1207的博客
06-08 360
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。
【玩转C语言】第一讲---＞C语言概念
Gao123456fy的博客
06-04 1423
【玩转C语言】第一讲--->C语言概念
【C++ | 析构函数】类的析构函数详解
wkd_007的博客
06-06 921
👉本文主要介绍类的析构函数的声明、定义、使用，以及析构函数在什么时候被调用。其实析构函数很简单，当你需要在对象被销毁时释放资源或内存时，就自己定义一个析构函数。
C++程序设计习题答案
08-12
- *1* *2* *3* [CODE:4737-C++程序设计（习题及答案）](https://blog.csdn.net/Jingmin1988/article/details/51333499)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值