C++综合实验 继承 静态数据成员 运算符重载 栈

最新推荐文章于 2022-04-07 18:08:14 发布
最新推荐文章于 2022-04-07 18:08:14 发布
阅读量219 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ningmengshuxiawo/article/details/118197445
版权

2:Composite

// 注意：无需提交main函数
#include<iostream>
#include<string>
#include<cstring>
using namespace std;
class CPU {
private:
	string cpuType0;
	double frequency0;
public:
	CPU(string a, double b) {
		cpuType0 = a;
		frequency0 = b;
	}
	CPU() {

	}
	void print1() {
		cout << "CPU type: " << cpuType0 << ", CPU frequency: "<<frequency0<<" GHz"<<endl;
	}
};
class Disk {
private:
	string diskType0; double capacity;
public:
	Disk(string c, double d) {
		diskType0 = c;
		capacity = d;
	}
	Disk() {

	}
	void print2() {
		cout << "disk type: " << diskType0 << ", disk capacity: " << capacity << " T " << endl;
	}
};
class Computer :virtual public CPU, virtual public Disk {
protected:
	int C3;
public:
	CPU cpu;
	Disk disk;
	Computer(string a1, double a2, string b2, double b3, int c1) : CPU(a1, a2), Disk(b2, b3) {
		C3 = c1;
	}
	Computer(CPU cpu, Disk disk)
	{
		this->cpu = cpu;
		this->disk = disk;		
	}
	void Print() {
		cout << "The computer has a cpu and a disk."<<endl;
		cpu.print1();
		disk.print2();
	}
};
int main()
{
    string cpuType, diskType;
    double frequency, capacity;
    cin >> cpuType >> frequency >> diskType >> capacity;
    CPU cpu(cpuType, frequency);
    Disk disk(diskType, capacity);
    Computer computer(cpu, disk);

    computer.Print();
    return 0;
}

在这里插入图片描述

3:静态数据成员

就是要注意在主函数中访问静态成员时，应先在主函数外面初始化静态成员

int Student::count = 0;

在这里插入图片描述

// 注意：无需提交main函数和Student类定义，提交Student类实现及其他相关代码
#include<iostream>
#include<string>
using namespace std;
class Student
{
private:
    int age;   //年龄
    string name;  //姓名
public:
    static int count; //静态成员，表示学生人数
    Student(int a, string n);
    Student();
    ~Student();
    void Print();
};

int Student::count = 0;
Student::Student(int a, string n)
{
	name = n;
	age = a;
	count++;
}

Student::Student()
{
	name = "NoName";
	age = 0;
	count++;
}

Student::~Student()
{
	count--;
}

void Student::Print()
{
	cout << "Name=" << name << ", age=" << age << endl;
}

int main()
{
    cout<<"count="<<Student::count<<endl;
    Student s1, *p=new Student(23,"ZhangHong");
    s1.Print();
    p->Print();
    delete p;
    s1.Print();
    Student Stu[4];
    cout<<"count="<<Student::count<<endl;
    return 0;
}

4:Ellipse

设椭圆的长轴为a，短轴为b,注意长轴可能是x轴，也可能是y轴
椭圆的面积计算 ：PI* a* b
椭圆的离心率计算：e=c/a; 其中c=sqrt(a * a -b * b)//此处假设a>b,否则调换a,b
判断一个点和椭圆的关系：

在平面上的任意点P和某椭圆的关系就这么三种；当点在椭圆内将点的坐标带入椭圆的方程根据椭圆的定义：椭圆上的点到两焦点的距离的和为2a, 根据点到点的距离方程就可列出椭圆的标准公式；若某点位于椭圆内，则该点到两焦点的距离的和就小于2a,若某点位于椭圆外，则该点到两焦点的距离的和就大于2a,

所以我们需要找到两个焦点，然后求给定点到焦点的距离，注意，焦点可能在x轴，也可能在y轴
在这里插入图片描述

#include<iostream>
#include<string>
#include<cmath>
using namespace std;
const double PI = acos(-1.0);
class Point
{
private:
	double x, y;
public:
	Point(double a = 0, double b = 0) :x(a), y(b) {}
	~Point() {}
	double getX() const { return x; }
	double getY() const { return y; }
	void setX(double a) { x = a; }
	void setY(double b) { y = b; }
};

class Ellipse
{
public:
	Point pAxis;
	Ellipse(double x = 0, double y = 0) :pAxis(x, y) { }
	~Ellipse() { }
	Ellipse(const Ellipse&);
	Ellipse transposition();    // 转置（交换长短半轴）
	double area();            // 面积
	double eccentricity();        // 离心率
	string position(const Point);    // 位置关系
};

int main()
{	
	double a, b;
	while (1)
	{
		cin >> a >> b;
		Ellipse d1(a, b), d2(d1), d3 = d2.transposition();
		cout << d1.area() << endl;	
		cout << d2.eccentricity() << endl;
		cin >> a >> b;
		Point p(a, b);
		cout << d3.position(p) << endl;
	}
	return 0;
}

Ellipse::Ellipse(const Ellipse &e)
{	
		this->pAxis.setX(e.pAxis.getX());
		this->pAxis.setY(e.pAxis.getY());
}

Ellipse Ellipse::transposition()
{
	double temp=this->pAxis.getX();
	double temp2 = this->pAxis.getY();
	Ellipse d(temp2, temp);
	return d;
}

double Ellipse::area()
{
	return PI * this->pAxis.getX()*this->pAxis.getY();
}

double Ellipse::eccentricity()
{
	double c = 0.0;
	if (this->pAxis.getX() > this->pAxis.getY())
	{
		c = sqrt(this->pAxis.getX()*this->pAxis.getX() - this->pAxis.getY()*this->pAxis.getY());
		return  (double)c /(double) this->pAxis.getX();
	}
	else
	{
		c = sqrt(this->pAxis.getY()*this->pAxis.getY()- this->pAxis.getX()*this->pAxis.getX());
		return  (double)c / (double)this->pAxis.getY();
	}
	
}

string Ellipse::position(const Point p)
{
	
	double c = 0.0;
	double jiaoju;
	Point q1,q2;
	if (this->pAxis.getX() > this->pAxis.getY())
	{
		c = sqrt(this->pAxis.getX()*this->pAxis.getX() - this->pAxis.getY()*this->pAxis.getY());
		q1.setX(c);	q1.setY(0);
		q2.setX(-c);q2.setY(0);
		jiaoju = 2 * this->pAxis.getX();
	}
	else
	{
		c = sqrt(this->pAxis.getY()*this->pAxis.getY() - this->pAxis.getX()*this->pAxis.getX());
		q1.setX(0);	q1.setY(c);
		q2.setX(0); q2.setY(-c);
		jiaoju = 2 * this->pAxis.getY();
	}
	

	double sum1 = sqrt((p.getX() - q1.getX())*(p.getX() - q1.getX()) + (p.getY() - q1.getY())*(p.getY() - q1.getY()));
	double sum2 = sqrt((p.getX() - q2.getX())*(p.getX() - q2.getX()) + (p.getY() - q2.getY())*(p.getY() - q2.getY()));
	
	
	if (sum1 + sum2 == jiaoju)
	{

		return "at";
	}
	else if (sum1 + sum2 < jiaoju)
	{
		return "inside";
	}
	else
	{		
		return "outside";
	}
	
}

在这里插入图片描述

5:AdvancedInheritance

// 注意：无需提交main函数
#include<iostream>
#include<string>
using namespace std;

class Animal {
public:
	string type;
	string color;
	Animal() {

	}
	Animal(string type, string color) {
		this->type = type;
		this->color = color;
	}
	virtual void Print()
	{

	}
};
class Fish :virtual public Animal {
public:
bool  Osteichthyes;
	Fish(string type,string color, bool  Osteichthyes) :Animal(type, color) {
		this->type = type;
		this->color = color;
		this->Osteichthyes = Osteichthyes;
	}
	virtual void Print()
	{
		cout << "type: " << type << ", color: " << color << ", Osteichthyes: " << Osteichthyes << endl;
	}
};

class Bird:virtual public Animal {
public:
	bool   daytime;
	Bird(string type, string color, bool  daytime) :Animal(type, color) {
		this->type = type;
		this->color = color;
		this->daytime = daytime;
	}
	virtual void Print()
	{
		cout << "type: " << type << ", color: " << color << ", daytime: " << daytime << endl;
	}
};
int main()
{
    Animal *animal;
    string type, color;
    bool Osteichthyes, daytime;
    cin >> type >> color >> Osteichthyes;
    Fish fish(type, color, Osteichthyes);
    fish.Print();
    animal = &fish;
    animal->Print();
    cin >> type >> color >> daytime;
    Bird bird(type, color, daytime);
    bird.Print();
    animal = &bird;
    animal->Print();
    return 0;
}

在这里插入图片描述

6:有理数类

设计一个有理数类Rational，要求对运算符“+”“-”“*”“/”和“+=”“-=”“=”“/=”进行重载，完成有理数的加减乘除以及加减乘除复合赋值运算；并且重载“<<”和“>>”操作符完成有理数的输入和输出。最后，重载“==”和“!=”比较两个有理数是否相等。

类的定义如下：

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


class Rational

{

private:

	int z;    //分子

	int m;    //分母

public:

	Rational(int a = 0, int b = 1);  //构造有理数分数，分子默认为0，分母默认为1

	Rational& yuefen(); //约分函数对分数化简

	friend Rational operator+(const Rational &r1, const Rational &r2);

	friend Rational operator-(const Rational &r1, const Rational &r2);

	friend Rational operator*(const Rational &r1, const Rational &r2);

	friend Rational operator/(const Rational &r1, const Rational &r2);

	Rational & operator+=(const Rational &r);

	Rational & operator-=(const Rational &r);

	Rational & operator*=(const Rational &r);

	Rational & operator/=(const Rational &r);

	friend bool operator==(const Rational &, const Rational &);//判断两个有理数是否相等

	friend bool operator!=(const Rational &, const Rational &);//判断两个有理数是否不等

	friend ostream & operator<<(ostream &, const Rational &);

	friend istream & operator>>(istream &, Rational &);

};

int main()
{
	Rational r1, r2, r3;

	while (1)
		
	{
		cin >> r1 >> r2;
		cout << "r1 = " << r1 << "\n" << "r2 = " << r2 << endl;
		r3 = r1 + r2;
		cout << "r1+r2 = " << r3 << endl;
		r3 = r1 - r2;
		cout << "r1-r2 = " << r3 << endl;
		r3 = r1 * r2;
		cout << "r1*r2 = " << r3 << endl;
		r3 = r1 / r2;

		cout << "r1/r2 = " << r3 << endl;
		cout << (r1 == r2) << " " << (r1 != r2) << endl;
		cout << (r1 += r2) << endl;
		cout << (r1 -= r2) << endl;
		cout << (r1 *= r2) << endl;
		cout << (r1 /= r2) << endl;
	}

	return 0;
}

Rational::Rational(int a, int b)
{

	this->z = a;
	this->m = b;
}

int gcd(int p, int q)
{
	/*if (p < 0) p = -p;
	if (q < 0) q = -q;*/
	if (q == 0)
	{
		return p;
	}
	else {
		int r = p % q;
		return gcd(q, r);
	}
}
Rational & Rational::yuefen()
{
	// TODO: 在此处插入 return 语句
	int a = gcd(this->m, this->z);
	this->m = this->m / a;
	this->z = this->z/ a;
	Rational r(this->z, this->m);
	return r;
}

Rational & Rational::operator+=(const Rational & r1)
{
	Rational r;
	r.m = this->m * r1.m;
	r.z = this->z*r1.m + this->m*r1.z;
	r = r.yuefen();
	this->m = r.m;
	this->z= r.z;

	return *this;
}

Rational & Rational::operator-=(const Rational & r3)
{
	// TODO: 在此处插入 return 语句
	Rational r;
	r.m =this->m * r3.m;
	r.z = this->z*r3.m - this->m*r3.z;
	r = r.yuefen();
	this->m = r.m;
	this->z = r.z;

	return *this;
}

Rational & Rational::operator*=(const Rational & r3)
{
	// TODO: 在此处插入 return 语句
	Rational r;
	r.m = this->m * r3.m;
	r.z = this->z * r3.z;
	r = r.yuefen();
	this->m = r.m;
	this->z = r.z;

	return *this;
}

Rational & Rational::operator/=(const Rational & r2)
{
	// TODO: 在此处插入 return 语句
	Rational r;
	r.m = this->m * r2.z;
	r.z = this->z * r2.m;
	r = r.yuefen();
	this->m = r.m;
	this->z = r.z;

	return *this;
}

Rational operator+(const Rational & r1, const Rational & r2)
{
	Rational r;
	r.m = r1.m * r2.m;
	r.z = r1.z*r2.m + r1.m*r2.z;
	r = r.yuefen();
	return r;
}

Rational operator-(const Rational & r1, const Rational & r2)
{
	Rational r;
	r.m = r1.m * r2.m;
	r.z = r1.z*r2.m - r1.m*r2.z;
	r = r.yuefen();
	return r;
}

Rational operator*(const Rational & r1, const Rational & r2)
{
	Rational r;
	r.m = r1.m * r2.m;
	r.z = r1.z * r2.z;
	r = r.yuefen();
	return r;
}

Rational operator/(const Rational & r1, const Rational & r2)
{
	Rational r;
	r.m = r1.m * r2.z;
	r.z = r1.z * r2.m;
	r = r.yuefen();
	return r;
}

bool operator==(const Rational &r1, const Rational &r2)
{
	if ((r1.m == r2.m) && (r1.z == r2.z))
		return true;
	return false;
}

bool operator!=(const Rational &r1, const Rational &r2)
{
	if (!((r1.m == r2.m) && (r1.z == r2.z)))
		return true;
	return false;
}

ostream & operator<<(ostream &output, const Rational &r1)
{
	// TODO: 在此处插入 return 语句	
    Rational r = r1;
    r = r.yuefen();
	if (r.z == 0)//等于0
	{
		output << r.z;
		return output;
	}

	if (r.z*r.m < 0)//有一个小于0
	{
		if (r.m <0)//分母小于0
		{
			output  << -r.z << "/" << -r.m;
		}
		else//分子小于0
		{
			output  << r.z << "/" << r.m;
		}
	
	}
	/*else if(r.z*r.m == 0)
	{
		if (r.m < 0)
		{
			output << "-" << -r.z << "/" << -r.m;
		}
		else
		{
			output << "-" << r.z << "/" << r.m;
		}
	}*/
	else if (r.m < 0 && r.z <= 0)//都小于0
	{
		output << -r.z << "/" <<-r.m;
	}	
	else//都不小于0
	{
		output << r.z << "/" << r.m;
	}
	
	return output;
}

istream & operator>>(istream &input, Rational &r)
{
	// TODO: 在此处插入 return 语句
	input >> r.z >> r.m;
	return input;
}

在这里插入图片描述

7:Line

// 注意：main函数已经存在，无需提交。仅提交Point2和Line2定义及实现
#include<iostream>
#include<string>
#include<cmath>
using namespace std;

template<class T> 
class Point2{

public:
	T x;
	T y;
	Point2()
	{
	}
	Point2(T x, T y)
	{
		this->x = x;
		this->y = y;
	}
};

template<class S>
class Line2 {

public:
	Point2<S> pt1;
	Point2<S> pt2;
	
	Line2(Point2<S> pt1, Point2 <S>pt2)
	{
		this->pt1 = pt1;
		this->pt2 = pt2;
	}
	
	S Length()
	{
      
		return sqrt((pt1.x - pt2.x)*(pt1.x - pt2.x) + (pt1.y - pt2.y)*(pt1.y - pt2.y));
	}

};
int main() 
{
    Point2<double> pt1(1.0, 1.0);
    Point2<double> pt2(3.0, 4.0);
    Line2<double> line(pt1, pt2);
    cout << line.Length() << endl;

    int x1,y1, x2, y2;
    cin >> x1 >> y1 >> x2 >> y2;
    Line2<int> nLine(Point2<int>(x1, y1), Point2<int>(x2, y2));
    cout << nLine.Length()<< endl;

    return 0;
}

在这里插入图片描述

8:铁轨

某城市有一个火车站，铁轨铺设如图所示。有n节车厢从A方向驶入车站，按进站顺序编号为1~n。你的任务是让它们按照某种特定的顺序进入B方向的铁轨并驶出车站。为了重组车厢，你可以借助中转站C。这是一个可以停放任意多节车厢的车站，但由于末端封闭，驶入C的车厢必须按照相反的顺序驶出C。对于每个车厢，一旦从A移入C，就不能再回到A了；一旦从C移入B，就不能回到C了。换句话说，在任一时刻，只有两种选择：A->C和C->B。

在这里插入图片描述
在这里插入图片描述

#include <iostream>
#include  <vector>
#include <stack>
#include <stdio.h>
#include <string.h>
using namespace std;
class Solution {
public:
	bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
		if (pushed.size() != popped.size()) return false;
		stack<int> stk;
		int i = 0;
		for (auto x : pushed) {
			stk.push(x);
			while (!stk.empty() && stk.top() == popped[i]) {
				stk.pop();
				i++;
			}
		}
		return stk.empty();
	}
};
int main()
{
	int n = 0;
	char s[1000];
	while (cin >> n)
	{	
	int a = 0;
	vector<int>pushed;
	vector<int>popped;
	Solution solution;	
	for (int i = 1; i <= n; i++)
	{
		pushed.push_back(i);
		cin >> a;
		popped.push_back(a);
	}
	if (solution.validateStackSequences(pushed, popped))
	{
		cout << "Yes" << endl;
	}
	else
	{
		cout << "No" << endl;
	}
	}

	//system("pause");
	return 0;
}
此生辽阔
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法——栈的实现与三种应用实例（C++）
Ripplesding的博客
07-17 1515
1 栈的实现 栈可以依托向量或者列表的类来实现，此处采用继承列表类的方法来实现，列表类的详情见class List。 #include <string.h> #include "../dsa_list_20200715/list.h" template <typename T> class Stack:public List<T> { public: void push ( T const& e ) { List<T>::insertAsLas
面向对象程序设计C++——利用链表实现栈和队列（继承）
ChristensonLee的博客
05-08 1683
**【问题描述】**利用链表实现栈和队列 队列具有先进先出的特点，所有新来的元素都放在队列尾部，出队列的元素从队列头部出去。下面是队列的示意图： 栈具有后进先出的特点。所有入栈的元素都放在栈顶，出栈时栈顶元素先出。下面是栈的示意图： 这两种结构具有很多相似的地方：都存放了一系列的元素，元素的操作都在两头进行，元素个数都是动态可变的。我们可以设计一个基类，完成它们共同的功能，然后分别派生出队列类和栈类。本实验要求以上一个实验实现的链表类作为基类并设计它的两个派生类。 要求： (1) 在上一个实验实现的链表
C++单链表简单实现栈和队列(继承和派生)
星辰大海的博客
04-04 2756
先上题目： 设计单链表类，并基于单链表类实现栈类和队列类： （1）设计学生信息类StudentRecord，要求包含公有数据成员：string stuName和int stuNo，设计用于输出学生信息的公有成员函数：void print()，输出格式为：Name: stuName, Number: stuNo。 （2）设计学生链表的结点类StudentNode，要求包含公有数据成员：Student...
数据结构顺序栈C++实现
Brillian123的博客
04-07 3201
栈，先入后出，根据存储方式可以分为顺序栈和链式栈。顺序栈的存储基于数组，链式栈的存储基于链表。 顺序栈就是以c语言的数组作为内存空间来构成的栈。栈顶指针top不再是c语言的指针类型，而是元素的下标。本文仍然使用模板的方法来实现，因为模板使用的内置数据类型较多，更全面。 1. 首先定义一下栈的通用接口，写在 “stack.h” 头文件中，通用接口为纯虚函数，方便顺序栈来继承和重写，以实现C++的多态。 “stack.h” 头文件代码如下： ...
算法竞赛入门经典——数据结构基础
linjiayina的博客
01-17 359
算法竞赛入门经典——数据结构基础 再谈栈和队列 问题：铁轨（UVa 514） 某城市有一个火车站，有n节车厢从A方向驶入车站，按进站顺序编号为1~n。你的任务是判断是否能让它们按照某种特定的顺序进入B方向的铁轨并驶出车站。例如，出栈顺序（5 4 1 2 3）是不可能的，但（5 4 3 2 1）是可能的。 为了重组车厢，你可以借助中转站C。这是一个可以停放任意多节车厢的车站，但由于末端封顶，驶入C的...
C++中的四个默认成员函数与运算符重载详解
08-29
主要给大家介绍了关于C++中四个默认成员函数与运算符重载的相关资料，文中通过示例代码介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面来跟着小编一起学习学习吧。
详解C++编程中一元运算符的重载
01-20
若要将一元运算符函数声明为非静态成员，则必须用以下形式声明它： ret-type operator op () 其中 ret-type 是返回类型，op 是上表中列出的运算符之一。 若要将一元运算符函数声明为全局函数，则必须用以下形式声明...
详解C++中的函数调用和下标以及成员访问运算符的重载
01-20
函数调用运算符必须是非静态成员函数。 函数调用运算符在重载时不会修改函数的调用方式；相反，它会在运算符应用于给定类的类型的对象时修改解释该运算符的方式。例如，以下代码通常没有意义： Poin
详解C++编程中一元运算符的重载.doc
最新发布
09-18
若要将一元运算符函数声明为非静态成员，则必须用以下形式声明它： ret-type operator op () 其中 ret-type 是返回类型，op 是上表中列出的运算符之一。 若要将一元运算符函数声明为全局函数，则必须用以下形式声明...
解析C++中不能重载为友元函数的四个运算符
12-26
现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为类的非静态成员函数，而不可以重载为类的友元函数。不能重载为类的静态成员应该比较容易理解，因为静态成员函数是属于整个类的，不是属于某个对象...
有理数_有理数类Rational_
09-29
/*设计一个有理数类Rational，要求对运算符“+”“-”“”“/”和“+=”“-=”“=”“/=”进行重载，完成有理数的加减乘除以及加减乘除复合赋值运算；并且重载“<<”和“>>”操作符完成有理数的输入和输出。最后，重载“==”和“!=”比较两个有理数是否相等。*/
c++ 编写的 有理数类
05-21
有理数类源代码。本程序主要实现有理数的加、减、乘、除以及一些比较运算。同时可以使用该有理数类实现简单的方程组求解及假分数转换为带分数。再设计该有理数时，主要重载了加、减、乘、除、比较运算符，同时还重载了将有理数输入数的“<<”和“>>”。在用已经定义好的有理数实现方程组的求解。主要就是用加、减、乘、除运算。
有理数运算 C++ 设计报告
10-20
定义并实现一个有理数类，通过重载运算符+、-、*、/对有理数进行算术运算，通过重载运算符＝＝实现判定两个有理数是否相等。写一个优化函数，它的作用是使有理数约去公分母，也即是使保存的有理数分子和分母只见没有公约数（出去1以外）。此外，还要定义一个将有理数 转换为实数的函数，再加上构造函数和有理数输出函数。
有理数类
海月的博客
02-23 1009
描述 设计一个有理数类Rational，要求对运算符“+”“-”“”“/”和“+=”“-=”“=”“/=”进行重载，完成有理数的加减乘除以及加减乘除复合赋值运算；并且重载“<<”和“>>”操作符完成有理数的输入和输出。最后，重载“==”和“!=”比较两个有理数是否相等。 类的定义如下： class Rational { private: int z; ...
设计一个有理数类，应该包含加，减，乘，除运算。
像蜗牛的Elric
05-05 3638
设计一个有理数类
类设计与声明之实现有理数类
一个菜鸟的博客
02-27 2400
占楼，学习并设计规则。 http://blog.csdn.net/qq_38238112/article/details/77416146 http://blog.csdn.net/chenkangli/article/details/489725 https://www.cnblogs.com/laizhenghong2012/p/8457784.html http://blog.csd...
实训C++语言设计——Rational有理数的运算实现
大师的资源
02-17 2313
平台：VC++ 2005 测试通过！.vcproj这是使用应用程序向导生成的 VC++ 项目的主项目文件。 它包含生成该文件的 Visual C++ 的版本信息，以及有关使用应用程序向导选择的平台、配置和项目功能的信息。StdAfx.h, StdAfx.cpp这些文件用于生成名为 twod.pch 的预编译头 (PCH) 文件和名为 StdAfx.obj 的预编译类型文件。这些都是使用应用程序向导
运算符重载----有理数类
smallgyy的专栏
05-03 5446
/* 定义一个有理数类Rational，重载算术运算符。写一个完整的程序，测试各种运算符的使用，要求输出化简后的计算结果，注意分母不能为零！ 测试代码样例： Rational A(2,6),B(1,-2),C; C = -A; C.print( );//输出1/3 C = A + B ; C.print( ); //输出-1/6
c语言计算火车的运行时间_C++火车入轨算法的实现代码
weixin_31232695的博客
01-17 1190
【问题描述】某城市有一个火车站，铁轨铺设如图所示。有n节车厢从A方向驶入车站，按进站顺序编号为1~n。你的任务是让它们按照某种特定的顺序进入B方向的铁轨并驶出车站。为了重组车厢，你可以借助中转站C。这是一个可以停放任意多节车厢的车站，但由于末端封顶，驶入C的车厢必须按照相反的顺序驶出。对于每个车厢，一旦从A移入C，就不能再回到A了；一旦从C移入B，就不能回到C了。换句话说，在任意时刻，只有两种选择...
c++下标运算符重载
09-15
C语言不允许将下标运算符函数作为外部函数来定义，它只能是非静态的成员函数。下标运算符的一般形式为T1 T::operator[](T2)，其中T是定义下标运算符的类，T2表示下标，它可以是任意类型，T1是数组运算的结果。为了能...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值