C++题目练习10

于 2024-08-04 13:25:14 发布
阅读量100 收藏 3
点赞数 2
文章标签： c++ 算法 数据结构 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74805385/article/details/140905165
版权

C++题目练习10

10.1 模板练习：数组最大值

设计一个函数模板，实现从int、long long、char、double、string类型的数组找出最大值元素。
提示：可用类型参数传递数组、用非类型参数传递数组大小。

#include <iostream>
#include <string>
using namespace std;

template<typename T>

T findMax(T *a, int n) {
	T max;
	max = a[0];
  
	for (int i = 1; i < n; i++) {
		if (max < a[i])
			max = a[i];
	}
	return max;
}


int main() {
	int n;
	cin >> n;
	int *a = new int[n];
	for ( int i = 0; i < n; i++ )
		cin >> a[i] ;
	cout << "1 " << findMax( a, n ) << endl;
	delete[] a;

	cin >> n;
	string *b = new string[n];
	for ( int i = 0; i < n; i++ )
		cin >> b[i] ;
	cout << "2 " << findMax( b, n ) << endl;
	delete[] b;

	cin >> n;
	long long *c = new long long[n];
	for ( int i = 0; i < n; i++ )
		cin >> c[i] ;
	cout << "3 " << findMax( c, n ) << endl;
	delete[] c;

	cin >> n;
	double *d = new double[n];
	for ( int i = 0; i < n; i++ )
		cin >> d[i] ;
	cout << "4 " << findMax( d, n ) << endl;
	delete[] d;

	return 0;
}

10.2 设计模板类 MyStack

请按要求实现一个 MyStack 类模板，要求实现数据的封装和各种常用操作。
约定：

  1. 数据成员为私有属性，包括：
  • data ：一个指针，指向存放栈元素的空间，栈元素类型为 T
  • tt ： 指示栈顶位置
  • siz : 当前栈空间的大小
  1. 成员函数为公有属性，包括：
  • 默认构造函数，完成初始化动作，栈空间的默认大小是 100 。
  • 带一个参数 s 的构造函数，s 表示栈空间的初始大小。
  • 析构函数：负责释放动态申请的内存。
  • 拷贝构造函数，实现深拷贝。
  • top( &v )，函数返回如果为真，参数 v 带回栈顶元素的值；函数返回如果为假，参数 v 的值没有变化。
  • pop()，如果栈不空，弹走栈顶元素；如果栈空，没有动作。
  • push( v )，如果栈已满，没有动作；如果栈未满，参数 v 的值进栈。
  • size()，返回当前栈内元素个数，如果栈空，返回 0 。
  • 重载 流插入运算符 << ：如果栈不空，自栈底到栈顶，输出栈内元素，每个元素后跟一个空格；如果栈空，没有输出。
  • 重载 赋值运算符 = ：将一个栈对象赋值给另一个栈对象，要实现深拷贝
  • 重载 等于比较运算符 == ： a 和 b 两个栈对象，当栈 a 的元素 与 栈 b 的元素个数相同且所有对应位置的元素相等时，表达式 a == b 为真

请实现上述功能。
完成 MyStack类 的 数据成员 以及 各成员函数 的实现。

#include<cstdio>
#include <iostream>
using namespace std;

template<typename T>
class MyStack {
   public:
    // 无参默认构造函数
    MyStack();

    // 带一个参数 int s 的构造函数
    MyStack( unsigned s );

    // 拷贝构造函数
    MyStack( const MyStack &b );

    // 析构函数
    ~MyStack();

    // 读取栈顶元素的值，赋值给 v
    bool top( T& v );

    // 弹出栈顶元素
    void pop();

    // 压v进栈
    bool push( const T& v );

    // 当前栈内元素个数
    unsigned size();

    // 重载 流插入运算符 <<
    friend ostream & operator<< ( ostream &out, const MyStack& a ) {
        if(a.data == nullptr || a.tt == -1)
		  return out;
		for(int i = 0;i<a.tt+1;i++)
		 out<< a.data[i] <<" ";
         out<<endl;
		return out; 
    }

    // 重载 赋值运算符 =
    MyStack & operator = ( const MyStack& b );

    // 等于 比较运算符 ==
    bool operator == ( const MyStack& b );

private:
    T *data;
    int tt;
    unsigned siz;
};

template<typename T>
MyStack<T>::MyStack()
{
	siz=100;
	data=new T[siz];
	tt=-1;
}

template<typename T>
MyStack<T>::MyStack(unsigned s)
{
	siz = s;
	data = new T[siz];
	tt=-1;
}

template<typename T>
MyStack<T>::MyStack(const MyStack &b)
{
	data  = new T[b.siz];
	siz = b.siz;
	for(int i =0;i<b.tt+1;i++)
	{
		data[i] = b.data[i];
	}
	tt = b.tt;
}
template<typename T>
MyStack<T>::~MyStack()
{
	if(data != nullptr)
	  delete[]data;
}

template<typename T>
bool MyStack<T>::top(T &v)
{
	if(tt == -1)
	 return false;
	v = data[tt];
	return true;
}

template<typename T>
void MyStack<T>::pop()
{
	if(tt == -1)
	{
		return;
	}
	tt--;
}

template<typename T>
bool MyStack<T>::push(const T &v)
{
	if(tt==siz-1)
	 return false;
	tt++;
	data[tt] = v;
	return true;
}

template<typename T>
unsigned MyStack<T>::size()
{
	return tt+1;
}

template<typename T>
MyStack<T> &MyStack<T>::operator=(const MyStack &b)
{
	if(this == &b)
	{
		return *this;
	}
	if(data!=nullptr)
	{
		delete[]data;
	}
	data = new T[b.siz];
	siz = b.siz;
	for(int i=0;i<b.tt+1;i++)
	{
		data[i] = b.data[i];
	}
	tt = b.tt;
	return *this;
 } 
 template<typename T>
 bool MyStack<T>::operator==(const MyStack &b)
 {
 	if(this == &b)
 	 return true;
 	if(tt != b.tt)
 	 return false;
 	for(int i=0;i<tt+1;i++)
 	{
 		if(data[i]!=b.data[i])
 		 return false;
	 }
	 return true;
  } 
int main() {

    int si;
    cin >> si;
    MyStack<int> s1( si );  // 创建一个栈空间大小为 si 的栈 s1

    int command;
    int c, v;

    cin >> command;  // 读入命令个数
    while( command -- ) {
        cin >> c;  // 读入一条命令
        switch( c ) {
        case 1:  // 进栈
            cin >> v;
            s1.push( v );
            break;
        case 2:  // 出栈
            s1.pop();
            break;
        case 3:  // 读取栈顶元素
            if( s1.top( v ) )  // 如果返回为真，说明成功读取栈顶元素
                cout << v << endl;  // 输出之
            break;
        case 4:  // 栈内元素的个数
            cout << s1.size() << endl;
            break;
        case 5:  // 利用重载的 流插入运算符 输出 栈s1
            cout << s1; // 笔记：换行符要放在 operator<<运算符重载函数里面输出，否则会造成PE
            break;
        }
    }

    MyStack<int> s2( s1 );  // 利用拷贝构造函数创建一个新对象 s2
    cin >> command;
    while( command -- ) {
        cin >> c;
        switch( c ) {
        case 1:  // 进栈
            cin >> v;
            s2.push( v );
            break;
        case 2:  // 出栈
            s2.pop();
            break;
        case 3:  // 读取栈顶元素
            if( s2.top( v ) )  // 如果返回为真，说明成功读取栈顶元素
                cout << v << endl;  // 输出之
            break;
        case 4:  // 栈内元素的个数
            cout << s2.size() << endl;
            break;
        case 5:  // 利用重载的 流插入运算符 输出 栈s2
            cout << s2;
            break;
        }
    }

    if( s1 == s2 )  // 利用重载的 等于比较运算符 判断 s1 == s2 是否为真
        cout << "yes" << endl;
    else
        cout << "no" << endl;

    MyStack<int> s3;  // 调用默认构造函数创建一个新对象 s3
    s3 = s1;  // 赋值运算符

    if( s3 == s1 )  // 利用重载的 等于比较运算符 判断 s3 == s1 是否为真
        cout << "yes" << endl;
    else
        cout << "no" << endl;

    cin >> command;
    while( command -- ) {
        cin >> c;
        switch( c ) {
        case 1:  // 进栈
            cin >> v;
            s3.push( v );
            break;
        case 2:  // 出栈
            s3.pop();
            break;
        case 3:  // 读取栈顶元素
            if( s3.top( v ) )  // 如果返回为真，说明成功读取栈顶元素
                cout << v << endl;  // 输出之
            break;
        case 4:  // 栈内元素的个数
            cout << s3.size() << endl;
            break;
        case 5:  // 利用重载的 流插入运算符 输出 栈s3
            cout << s3;
            break;
        }
    }

    return 0;
}

10.3 模版类Array

请实现一个模版类 Array ，实现可以直接访问的线性群体，包括：私有数据成员：

  • T* list;    /// 用于存放动态分配的数组内存首地址
  • int siz;    /// 数组大小。为了避免与 size 同名而高亮显示，特意减少一个字符

成员函数：

  • 构造函数 ： Array( int sz = 10 )
  • 拷贝构造函数 ： Array( const Array<T> &a )
  • 析构函数 ： ~Array()
  • 重载赋值运算符 operator = ： operator = ( const Array<T> &rhs )
  • 重载 下标运算符[] ，用于 左值： operator [] ( int i )
  • 重载 下标运算符[] 常函数，用于 右值 ： operator [] ( int i ) const
  • 重载到 T* 类型的转换 ：operator T * ()
  • 取数组的大小 ： getSize()
  • 修改数组的大小 ： resize( int sz )
#include <iostream>
#include <cassert>
#include <iomanip>
using namespace std;

template<class T>
class Array
{
	private:
		T *list;
		int siz;
	public:
		Array(int sz = 10)
		{
			siz = sz;
			list = new T[siz];
		}
		Array(const Array<T>&a)
		{
			siz = a.siz;
			list = new T[siz];
			for(int i = 0;i<siz;i++)
			{
				list[i] = a.list[i];
			}
		}
		~Array()
		{
			delete[] list;
			
		}
		Array<T>& operator = (const Array<T> &rhs)
		{
			if(this != &rhs)
			{
				delete[] list;
				siz = rhs.siz;
				list = new T[siz];
				for(int i = 0;i<siz;i++)
				{
					list[i] = rhs.list[i];
				}
			}
			return *this;
		}
		T& operator[](int i)
		{
			assert(i>=0 && i<siz);
			return list[i];
		}
		const T& operator[](int i) const {
        assert(i >= 0 && i < siz);
        return list[i];
    }

    operator T*() {
        return list;
    }

    int getSize(){
        return siz;
    }

    void resize(int sz) {
        T* newList = new T[sz];
        for (int i = 0; i < min(siz, sz); i++) {
            newList[i] = list[i];
        }
        delete[] list;
        list = newList;
        siz = sz;
    }
};

/// read() 用于验证 重载的指针转换运算符
void read( double *p, int n ) {
    for ( int i = 0; i < n; i++ )
        cin >> p[i];
}

int main() {
    int n;
    cin >> n;
    
    Array<double> da(n);    /// 创建一个 double类型元素 的 对象da
    read( da, n );
    
    /// 输出 Array类的 对象da 全部元素
    for ( int i = 0; i < da.getSize(); i++ )
        cout << da[i] << ' ';
    cout << endl;
    
    Array<int> prime(5);    /// 创建一个 int类型元素 的 对象prime
    /// 求 [2, n] 的全部素数，存放到 prime 中

    int cnt = 0; /// 统计当前找到的素数的个数
    cin >> n;  /// 读入范围

    for ( int i = 2; i <= n; i ++ ) {   /// 检查 i 是否能被比它小的素数整除
        bool isPrime = true;
        for ( int j = 0; j < cnt; j ++ )
            /// 若 i 被 prime[j] 整除，说明 i 不是质数
            if ( i % prime[j] == 0 ) {
                isPrime = false;
                break;
            }

        if ( isPrime ) {
            if ( cnt == prime.getSize() )   /// 当装满了
                prime.resize( cnt * 2 );    /// 空间扩大一倍
            prime[ cnt ++ ] = i;
        }
    }
    
    for ( int i = 0; i < cnt; i ++ )
        cout << setw(8) << prime[i];
    cout << endl;
    
    return 0;
}

 

m0_74805385
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++练习题目
A996B的博客
05-08 1415
文章开始前的废话： 今天我们来开一个新坑--C++！！ 不废话上图片： わあ、かっこいい、私はもう陥落した。（并不想让您们知道什么意思，就不说中文了） 题目一： 题目： 输入一个长度为n的数组，输出他的最大值和最小值。 输入： 第一行一个整数n，表示数组长度，1≤n≤100000； 接下来n行，每行一个整数ai，表示数组的内容，-214748364...
C++循环经典练习题
m0_74067556的博客
07-04 704
在C++的海洋中，循环是一座宝藏岛，等待着勇敢的探索者去征服。正如一位著名程序员曾经说过：“没有循环，编程就像是一个没有尽头的迷宫，所以循环题目便是我们走向编程巅峰的重要阶梯。”想要成为C++的大师，你需要经历循环的洗礼，解决经典的练习题。本篇博客将向你展示一系列C++循环的经典练习题，帮助你在循环的世界中获得进一步的成长和掌握。让我们一同踏上这充满挑战与乐趣的征程吧！
c++题目练习
weixin_57486404的博客
05-01 229
c++
C++题目练习讲解
2301_76393304的博客
02-03 177
导语
继承练习题目C++
weixin_61009782的博客
05-14 1244
继承练习1 ①声明并实现一个名为Person的基类，Person类有保护数据成员name（姓名，string类型）、sex（性别，char类型，'M'表示男，'F'表示女）。以及有参构造函数，将姓名、性别设置为给定的参数；成员函数print，输出姓名和性别。‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬ ②从Person类派生出Student类，Stude
C++ 函数递归练习
qq_58710019的博客
10-30 333
【代码】C++ 函数递归练习。
C++数组练习
qq_41135440的博客
06-10 1294
C++数组练习！
C++案例练习：循环
m0_66319534的博客
07-20 1445
2.案例描述从1开始数到数字100，如果数字个位含有7，或者数字十位含有7，或者该数字是7的倍数，我们打印敲桌子，其余数字直接打印输出。1.案例描述水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身。请利用do...while语句，求出所有3位数中的水仙花数。例如1^3+5^3+3^3=153。3.简单的嵌套循环案例。...
C++枚举练习
加油~
01-21 1333
枚举练习1、举例出小于某个数的所有质数代码代码运行2、求某数到某数之间中为回文数且每位和为n的数。示例代码代码运行3、避免“不幸运的”4代码要求代码代码运行4、四平方定理（拉格朗日定理）代码要求代码代码运行 1、举例出小于某个数的所有质数 代码 #include<iostream> using namespace std; int main() { int x; cin >> x; int con = 0; for (int i = 2; i <=x; i++) {
c++练习(10)：链表练习
@bangbang的博客
07-31 1016
寻找特定位置,runner以两倍速前进,chaser一倍速，当runner到达tail时，chaser即为所求解。给定一个链表和一个数值，写一个函数重新排序链表，使得小于给定值的节点排在链表的左边,大于给点值的节点排在链表右侧。在head之前并指向head只要涉及操作head节点，当头节点操作不确定的时候，不妨创建dummynode;并且可以用一个简单的小testcase来验证(例如长度为4和5的list)对于寻找list某个特定位置的问题，不妨用两个变量。链表的头节点是否为。...
自主练习题目c++测试(1)(3).zip
03-25
"自主练习题目c++测试(1)(3).zip"这个压缩包显然包含了针对C++学习者设计的一系列练习题，旨在帮助学生巩固期中或期末所学的知识点。通过解答这些题目，学习者可以更好地理解和掌握C++的基础概念、语法以及编程技巧...
C++编程练习题大全(带答案).pdf
03-06
409页C++练习题，涵盖了入门习题，提高习题，同时也包含了大量基础算法及一些链表、队列等算法习题，方便在入门C++的同时，对一些算法进行了解。
50道C++编程练习题及解答.doc
06-22
C++的常见习题，适合初步学习，巩固基础，复习提升。每道题目都有对应的答案，可以直接运行。适合用作C++的专项练习。内容可以参考我的博客。
50道c++编程练习题（只有题目）
03-29
50道经典习题，简介但不失经典，为c++初学者提供一定的指导，很值得学习
二叉树的中序遍历 - 力扣（LeetCode）C语言
最新发布
SikJ_2020_0_24的博客
08-03 126
注：本题中returnSize，指的是二叉树的结点数，返回的必须是malloc开辟的。递归算法很简单，你可以通过迭代算法完成吗？注意要点与前序遍历相同，请参考。（点击前面链接即可查看题目）给定一个二叉树的根节点。
【C++】输入输出
2401_83948390的博客
08-02 370
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
3.C_Demo_最大公约数、最小公倍数
Fresh_man111的博客
08-03 145
假设两个数字a和b，求两个数字相除的余数c=a%b，如果余数为0，则b为最大公约数。如果b不为零，a=b,b=c,继续循环计算。两个数的最小公倍数数等于两个数的乘积除以两个数的最大公约数。即：x，y的最小公倍数 min(公倍数)=x*y÷max(公约数)参数a，b：传入的两个数值，两个数都不能为0。参数a，b：传入的两个数值，不能全为0。返回值：0代表错误，正常返回最大公约数。返回值：0代表错误，正常返回最小公倍数。功能：求a，b最大公约数。功能：求a，b最小公倍数。
【leetcode详解】正方形中的最多点数【中等】(C++思路精析)
H13420972436的博客
08-03 413
题目分析： 一个点是否在题给正方形中，只取决于其横纵坐标的最大值，记为dis沟通二位数组points和字符串s的桥梁，就是这个点的序号，记为idx由此自定义结构体，储存dis 和idx//其中bool operator部分的功能：重载小于操作符“
c++ 课堂练习题目
09-02
C课堂练习题目是一个对于学习者来说非常重要的环节。通过解答这些题目，我们可以巩固知识、检验理解、培养思维能力。在解答C课堂练习题目时，我们应该注意以下几点。 首先，要注意题目的理解。仔细阅读题目，理解题目所要求的内容和要点。只有明确题目要求，才能准确回答问题。 其次，要运用所学知识进行解答。C课堂练习题目主要涉及C语言的相关知识点，包括语法规则、数据类型、控制结构、函数等等。我们需要充分运用所学知识，通过分析问题，编写代码来解决问题。 同时，要注重练习和实践。练习是提高能力的关键，通过大量的练习，我们可以更好地掌握知识和技能。所以，在回答课堂练习题目时，应该积极动手实践，不断练习，不断巩固和提高自己的能力。 最后，要注意思维的灵活性和创新性。在解答C课堂练习题目时，我们要注重培养自己的思维能力，灵活运用所学知识，提出创新的解决方法。只有通过不断思考和实践，才能提高解决问题的能力。 总之，回答C课堂练习题目是一个很好的学习和巩固知识的机会。通过理解题目、运用所学知识、实践和思考，我们可以提高解决问题的能力。希望每个同学都能够认真对待每一个练习题目，不断提高自己的能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值