C++ Primer Plus 第十一章答案 使用类

最新推荐文章于 2023-05-15 13:55:27 发布
最新推荐文章于 2023-05-15 13:55:27 发布
阅读量209 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56677326/article/details/118212046
版权

复习题

#pragma once//避免此头文件被包含多次，和#ifndef的作用类似
//11.8
//1
Stonewt operator*(double mult);//原型
Stonewt Stonewt::operator*(double mult) {
	return Stonewt(mult * pounds);
}

//2
成员函数是类定义的一部分，通过特定的对象来调用。成员函数可以隐式地访问调用对象的成员，
而无需使用成员运算符。友元函数不是类的组成部分，因此被称为直接函数调用。友元函数不能
隐式地访问类成员，必须将成员运算符用于作为参数传递的对象。可比较复习题1和4

//3
要访问私有成员，必须是友元，要访问公有成员，可以不是友元

//4
friend Stonewt operator*(double mult, const Stonewt& w);//原型
Stonewt operator*(double mult, const Stonewt& w) {//函数定义
	return Stonewt(mult * w.pounds);
}

//5
\sizeof\.\.*\::\ ? : \
\typeid\const_cast\dynamic_cast\reinterpret_cast\static_cast\

//6
这些运算符必须使用成员函数定义

//7
operator double()const { return mag; }

practice 1

找不到程序清单复制粘贴，就很难受

//vect.h -- Vector class with <<,mode state
#pragma once//避免此头文件被包含多次，和#ifndef的作用类似
#ifndef VECT_H_
#define VECT_H_
#include<iostream>
namespace VECTOR {
	class Vector {
	public:
		enum Mode{RECT,POL};
		//RECT for rectangular,POL for Polar modes
	private:
		double x;
		double y;
		double mag;
		double ang;
		Mode mode;
		//Private methods for setting values
		void set_mag();
		void set_ang();
		void set_x();
		void set_y();
	public:
		Vector();
		Vector(double n1, double n2, Mode form = RECT);
		void reset(double n1, double n2, Mode form = RECT);
		~Vector();
		double xval() { return x; }
		double yval() { return y; }
		double magval() { return mag; }
		double angval() { return ang; }
		void polar_mode();
		void rect_mode();
		//operator overloading
		Vector operator+(const Vector& b)const;
		Vector operator-(const Vector& b)const;
		Vector operator-()const;
		Vector operator*(double n)const;
		//friends
		friend Vector operator*(double n, const Vector& a);
		friend std::ostream& operator<<(std::ostream& os, const Vector& v);
	};
}//end namespace VECTOR
#endif



//vect.cpp -- methods for the Vector class
#include<cmath>
#include"vect.h"
using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

namespace VECTOR {
	//compute degrees in one radian
	const double Rad_to_deg = 45.0 / atan(1.0);
	//should be about 57.2957795130823

	//private method
	//calculates magnitude from x and y
	void Vector::set_mag() 
	{
		mag = sqrt(x * x + y * y);
	}

	void Vector::set_ang() 
	{
		if (x == 0.0 && y == 0.0)
			ang = 0.0;
		else
			ang = atan2(y, x);
	}

	//set x from polar coordinate
	void Vector::set_x()
	{
		x = mag * cos(ang);
	}

	//set y from polar coordinate
	void Vector::set_y()
	{
		y = mag * sin(ang);
	}

	//public metohds
	Vector::Vector()
	{
		x = y = mag = ang = 0.0;
		mode = RECT;
	}

	//construct vector from rectangular coordinates if form is r
	//(the default)or else from polar coordinates if form is p
	Vector::Vector(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
			set_mag();
			set_ang();
		}
		else if (form == POL)
		{
			mag = n1;
			ang = n2;
			set_x();
			set_y();
		}
		else
		{
			cout << "Incorrent 3rd argument to Vector() -- ";
			cout << "Vector set to 0\n";
			x = y = mag = ang = 0.0;
			mode = RECT;
		}
	}

	//reset vector from rectangular coordinates if form is
	//RECT(the default) or else form polar coordinates if
	//form is POL
	void Vector::reset(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
			set_mag();
			set_ang();
		}
		else if (form == POL)
		{
			mag = n1;
			ang = n2;
			set_x();
			set_y();
		}
		else
		{
			cout << "Incorrent 3rd argument to Vector() -- ";
			cout << "Vector set to 0\n";
			x = y = mag = ang = 0.0;
			mode = RECT;
		}
	}

	Vector::~Vector()
	{
	}

	void Vector::polar_mode()
	{
		mode = POL;
	}

	void Vector::rect_mode()
	{
		mode = RECT;
	}

	//operator overloading
	//add two Vectors
	Vector Vector::operator+(const Vector& b)const
	{
		return Vector(x + b.x, y + b.y);
	}

	//subtract Vector b from a
	Vector Vector::operator-(const Vector& b)const
	{
		return Vector(x - b.x, y - b.y);
	}

	//reverse sign of Vector
	Vector Vector::operator-()const
	{
		return Vector(-x, -y);
	}

	//multiply Vector by n
	Vector Vector::operator*(double n)const
	{
		return Vector(n * x, n * y);
	}

	//friend methods
	//multiply n by Vector a
	Vector operator*(double n, Vector& a)
	{
		return a * n;
	}

	//display rectangular coordinate if mode is RECT
	//else display polar coordinates if mode is POL
	std::ostream& operator<<(std::ostream& os, const Vector& v)
	{
		if (v.mode == Vector::RECT)
			os << "(x,y) = (" << v.x << "," << v.y << ")";
		else if (v.mode == Vector::POL)
			os << "(m,a) = " << v.mag << "," 
			<< v.ang * Rad_to_deg << ")";
		else
			os << "Vector object mode is invalid.";
		return os;
	}
}//end namespace VECTOR



//randwalk.cpp -- suing the Vector class
//compile with the vect.cpp file
#include<iostream>
#include<cstdlib>
#include<ctime>
#include"vect.h"
#include<fstream>
int main() {
	using namespace std;
	using namespace VECTOR;
	srand(time(0));
	double direction;//方向:角度
	Vector step;//创建类矢量:每一步
	Vector result(0, 0);//结果:累积矢量
	unsigned long steps = 0;//步数
	double target = 100;//目标距离
	double dstep = 20;//每一步长度
	ofstream fout;
	fout.open("jieguo.txt");
	fout << "Target Distance: " << target << ", Step Size: " << dstep << endl;
	fout << steps << ": " << result << endl;
	while (result.magval() < target)
	{
		direction = rand() % 360;
		step.reset(dstep, direction, Vector::POL);
		result = result + step;
		steps++;
		fout << steps << ": " << result << endl;
	}
	fout << "After " << steps << " steps,the subject "
		<< "has the following location:\n";
	fout << result << endl;
	result.polar_mode();
	fout << " or " << endl << result << endl;
	fout << "Average outward distance per step = "
		<< result.magval() / steps << endl;
	fout << "Bye!\n";
	return 0;
}

运行结果如下：

practice 2

针对practice 1的答案做如下修改，因为不能存储mag和ang

1，因此要更改四个计算x,y,mag,ang的私有方法，前两个要返回double值以使用，后两个要传递两个double参数。

2，公有方法里的返回mag和ang值的内联函数magval(),angval()需要修改，在main里面会用到。

3，显然构造函数也需要对应的修改。

4，修改reset()，与带参数的构造函数一致。

5，最后修改<<运算符的重载函数，这里可能出现错误
 E1086    对象含有与成员 函数 "VECTOR::Vector::angval" 不兼容的类型限定符。有两种可能

        1）const对象只能调用const函数

        2）const函数中不小心修改了类成员或者调用了非常量函数

因为要显示mag和ang用到了修改后的set_mag(),set_ang()，这两个函数进行了运算不是常量函数

所以去掉参数列表的const就可以了，注意原型的const也要去掉，不然就会有各种奇奇怪怪的错误

6，最后把randwalk.cpp的代码改成和程序清单11.15完全一样就可以了。

//vect.h -- Vector class with <<,mode state
#pragma once//避免此头文件被包含多次，和#ifndef的作用类似
#ifndef VECT_H_
#define VECT_H_
#include<iostream>
namespace VECTOR {
	class Vector {
	public:
		enum Mode{RECT,POL};
		//RECT for rectangular,POL for Polar modes
	private:
		double x;
		double y;
		Mode mode;
		//Private methods for setting values
		double set_mag();
		double set_ang();
		double set_x(double mag,double ang);
		double set_y(double mag,double ang);
	public:
		Vector();
		Vector(double n1, double n2, Mode form = RECT);
		void reset(double n1, double n2, Mode form = RECT);
		~Vector();
		double xval() { return x; }
		double yval() { return y; }
		double magval() { return set_mag(); }
		double angval() { return set_ang(); }
		void polar_mode();
		void rect_mode();
		//operator overloading
		Vector operator+(const Vector& b)const;
		Vector operator-(const Vector& b)const;
		Vector operator-()const;
		Vector operator*(double n)const;
		//friends
		friend Vector operator*(double n, const Vector& a);
		friend std::ostream& operator<<(std::ostream& os, Vector& v);
	};
}//end namespace VECTOR
#endif



//vect.cpp -- methods for the Vector class
#include<cmath>
#include"vect.h"
using std::sqrt;
using std::sin;
using std::cos;
using std::atan;
using std::atan2;
using std::cout;

namespace VECTOR {
	//compute degrees in one radian
	const double Rad_to_deg = 45.0 / atan(1.0);
	//should be about 57.2957795130823

	//private method
	//calculates magnitude from x and y
	double Vector::set_mag()
	{
		return sqrt(x * x + y * y);
	}

	double Vector::set_ang()
	{
		if (x == 0.0 && y == 0.0)
			return 0.0;
		else
			return atan2(y, x);
	}

	//set x from polar coordinate
	double Vector::set_x(double mag, double ang)
	{
		return x = mag * cos(ang);
	}

	//set y from polar coordinate
	double Vector::set_y(double mag, double ang)
	{
		return y = mag * sin(ang);
	}

	//public metohds
	Vector::Vector()
	{
		x = y = 0.0;
		mode = RECT;
	}

	//construct vector from rectangular coordinates if form is r
	//(the default)or else from polar coordinates if form is p
	Vector::Vector(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
		}
		else if (form == POL)
		{
			set_x(n1,n2);
			set_y(n1,n2);
		}
		else
		{
			cout << "Incorrent 3rd argument to Vector() -- ";
			cout << "Vector set to 0\n";
			x = y = 0.0;
			mode = RECT;
		}
	}

	//reset vector from rectangular coordinates if form is
	//RECT(the default) or else form polar coordinates if
	//form is POL
	void Vector::reset(double n1, double n2, Mode form)
	{
		mode = form;
		if (form == RECT)
		{
			x = n1;
			y = n2;
		}
		else if (form == POL)
		{
			set_x(n1, n2);
			set_y(n1, n2);
		}
		else
		{
			cout << "Incorrent 3rd argument to Vector() -- ";
			cout << "Vector set to 0\n";
			x = y = 0.0;
			mode = RECT;
		}
	}

	Vector::~Vector()
	{
	}

	void Vector::polar_mode()
	{
		mode = POL;
	}

	void Vector::rect_mode()
	{
		mode = RECT;
	}

	//operator overloading
	//add two Vectors
	Vector Vector::operator+(const Vector& b)const
	{
		return Vector(x + b.x, y + b.y);
	}

	//subtract Vector b from a
	Vector Vector::operator-(const Vector& b)const
	{
		return Vector(x - b.x, y - b.y);
	}

	//reverse sign of Vector
	Vector Vector::operator-()const
	{
		return Vector(-x, -y);
	}

	//multiply Vector by n
	Vector Vector::operator*(double n)const
	{
		return Vector(n * x, n * y);
	}

	//friend methods
	//multiply n by Vector a
	Vector operator*(double n, Vector& a)
	{
		return a * n;
	}

	//display rectangular coordinate if mode is RECT
	//else display polar coordinates if mode is POL
	std::ostream& operator<<(std::ostream& os, Vector& v)
	{
		if (v.mode == Vector::RECT)
			os << "(x,y) = (" << v.x << "," << v.y << ")";
		else if (v.mode == Vector::POL)
			os << "(m,a) = " << "(" << v.set_mag() << ", "
			<< v.set_ang() * Rad_to_deg << ")";
		else
			os << "Vector object mode is invalid.";
		return os;
	}
}//end namespace VECTOR



//randwalk.cpp -- suing the Vector class
//compile with the vect.cpp file
#include<iostream>
#include<cstdlib>
#include<ctime>
#include"vect.h"
#include<fstream>
int main() {
	using namespace std;
	using namespace VECTOR;
	srand(time(0));
	double direction;//方向:角度
	Vector step;//创建类矢量:每一步
	Vector result(0, 0);//结果:累积矢量
	unsigned long steps = 0;//步数
	double target;//目标距离
	double dstep;//每一步长度
	cout << "Enter target distance (q to quit): ";
	while (cin >> target)
	{
		cout << "Enter step length: ";
		if (!(cin >> dstep))
			break;
		while (result.magval() < target)
		{
			direction = rand() % 360;
			step.reset(dstep, direction, Vector::POL);
			result = result + step;
			steps++;
		}
		cout << "After " << steps << " steps,the subject "
			<< "has the following location:\n";
		cout << result << endl;
		result.polar_mode();
		cout << " or\n " << result << endl;
		cout << "Average outward distance per step = "
			<< result.magval() / steps << endl;
		steps = 0;
		result.reset(0, 0);
		cout << "Enter target distance (q to quit): ";
	}
	cout << "Bye!";
	cin.clear();
	while (cin.get() != '\n')
		continue;
	return 0;
}

practice 3

这题还是用原来的vect.h和vect.cpp，所以就不重复发代码了，直接复制practice 1，和书上的程序清单完全一致，抄了我半天。

这里我把vect.h里面类声明里面的enum改成了enum class，因为一直有警告要求首选enum class，注意把后面的RECT,POL加上限定符Mode::

//randwalk.cpp -- suing the Vector class
//compile with the vect.cpp file
#include<iostream>
#include<cstdlib>
#include<ctime>
#include"vect.h"
#include<fstream>
int main() {
	using namespace std;
	using namespace VECTOR;
	srand(time(0));
	double direction;//方向:角度
	Vector step;//创建类矢量:每一步
	Vector result(0, 0);//结果:累积矢量
	unsigned long steps = 0;//步数
	double target;//目标距离
	double dstep;//每一步长度
	int N;//执行次数
	cout << "Enter target distance (q to quit): ";
	cin >> target;
	cout << "Enter step length: ";
	cin >> dstep;
	cout << "Enter the execution times: ";
	cin >> N;
	unsigned long max = 0;
	unsigned long min = 0;
	unsigned long total = 0;
	for (int i = 0; i < N; i++)
	{
		while (result.magval() < target)
		{
			direction = rand() % 360;
			step.reset(dstep, direction, Vector::Mode::POL);
			result = result + step;
			steps++;
		}
		if (i == 0)
			max = min = steps;
		else
		{
			if (steps > max)
				max = steps;
			if (steps < min)
				min = steps;
			total += steps;
		}
		steps = 0;
		result.reset(0.0, 0.0);
	}
	cout << "Report the result of tests: "
		<< "The maximum steps: " << max << endl
		<< "The minimum steps: " << min << endl
		<< "The average steps: " << double(total)/N << endl;
	cout << "Bye!";
	return 0;
}

practice 4

//mytime.h -- Time class with friends
#pragma once//避免此头文件被包含多次，和#ifndef的作用类似
#ifndef MYTIME_H_
#define MYTIME_H_
#include<iostream>
class Time {
private:
	int hours;
	int minutes;
public:
	Time();
	Time(int h, int m = 0);
	void AddMin(int m);
	void AddHr(int h);
	void Reset(int h = 0, int m = 0);
	friend Time operator+(const Time& t1, const Time& t2);
	friend Time operator-(const Time& t1, const Time& t2);
	friend 	Time operator*(const Time& t, const double n);
	friend 	Time operator*(const double n, const Time& t)
	{
		return t * n;
	}
	friend std::ostream& operator<<(std::ostream& os, const Time& t);
};
#endif




//mytime.cpp -- implementing Time methods
#include"mytime.h"
Time::Time()
{
	hours = minutes = 0;
}
Time::Time(int h, int m)
{
	hours = h;
	minutes = m;
}
void Time::AddMin(int m)
{
	minutes += m;
	hours += minutes / 60;
	minutes %= 60;
}
void Time::AddHr(int h)
{
	hours += h;
}
void Time::Reset(int h, int m)
{
	hours = h;
	minutes = m;
}
Time operator+(const Time& t1, const Time& t2)
{
	Time time;
	time.minutes = t1.minutes + t2.minutes;;
	time.hours = t1.hours + t2.hours + time.minutes / 60;
	time.minutes %= 60;
	return time;
}
Time operator-(const Time& t1, const Time& t2)
{
	Time time;
	int tot1, tot2;
	tot1 = t1.minutes + t1.hours * 60;
	tot2 = t2.minutes + t2.hours * 60;
	time.hours = (tot1 - tot2) / 60;
	time.minutes = (tot1 - tot2) % 60;
	return time;
}
Time operator*(const Time& t, double n)
{
	Time time;
	long totalminutes = t.hours * 60 * n + t.minutes * n;
	time.hours = totalminutes / 60;
	time.minutes = totalminutes % 60;
	return time;
}
std::ostream& operator<<(std::ostream& os, const Time& t)
{
	os << t.hours << " hours, " << t.minutes << " minutes";
	return os;
}





//usetime.cpp -- using the Time class
//compile with the mytime.cpp file
#include<iostream>
#include"mytime.h"
int main()
{
	using std::cout;
	using std::endl;
	Time aida(3, 35);
	Time tosca(2, 48);
	Time temp;
	cout << "Aida and Tosca:\n";
	cout << aida << "; " << tosca << endl;
	temp = aida + tosca;
	cout << "Aida+Tosca = " << temp << endl;
	temp = aida * 1.17;
	cout << "Aida*1.17 = " << temp << endl;
	cout << "10.0*Tosca = " << 10.0 * tosca << endl;
	return 0;
}

practice 5

//stonewt.h -- definition for the Stone class
#pragma once//避免此头文件被包含多次，和#ifndef的作用类似
#ifndef STONEWT_H_
#define STONEWT_H_
#include<iostream>
class Stonewt {
public:
	enum class Mode { STN, PDS_INT, PDS };
private:
	enum { Lbs_per_stn = 14 };
	int stone;
	double pds_left;
	double pounds;
	int pds_int;
	Mode mode;
	void pds_stn(){
		stone = pounds / Lbs_per_stn;
		pds_left = pounds - stone * Lbs_per_stn;
	}
	void pds_pdsint() {
		pds_int = int(pounds);
	}
	void stn_pds() {
		pounds = stone * Lbs_per_stn + pds_left;
	}
public:
	Stonewt(double pds);
	Stonewt(int stn, double pdsl);
	Stonewt();
	~Stonewt();
	Stonewt operator + (const Stonewt & s)const;
	Stonewt operator - (const Stonewt & s)const;
	Stonewt operator * (double mul)const;
	void mode_STN() { mode = Mode::STN; }
	void mode_PDS() { mode = Mode::PDS; }
	void mode_PDS_INT() { mode = Mode::PDS_INT; }
	friend Stonewt operator*(double mult, const Stonewt& s)
	{
		return s * mult;
	}
	friend std::ostream& operator<<(std::ostream& os, const Stonewt& s);
};
#endif




//stonewt.cpp -- implementing Stonewt methods
#include"stonewt.h"
#include<iostream>
Stonewt::Stonewt(double pds)
{
	pounds = pds;
	pds_stn();
	pds_pdsint();
	mode = Mode::PDS;
}
Stonewt::Stonewt(int stn, double pdsl)
{
	stone = stn;
	pds_left = pdsl;
	stn_pds();
	pds_pdsint();
	mode = Mode::STN;
}
Stonewt::Stonewt() {
	pounds = stone = pds_left = 0;
	pds_int = 0;
	mode = Mode::PDS;
}
Stonewt::~Stonewt(){}
Stonewt Stonewt::operator + (const Stonewt& s)const
{
	Stonewt swt;
	swt.pounds = pounds + s.pounds;
	return Stonewt(swt.pounds);
}
Stonewt Stonewt::operator - (const Stonewt& s)const
{
	Stonewt swt;
	swt.pounds = pounds - s.pounds;
	return Stonewt(swt.pounds);
}
Stonewt Stonewt::operator * (double mult)const
{
	Stonewt swt;
	swt.pounds = pounds * mult;
	return Stonewt(swt.pounds);
}

std::ostream& operator<<(std::ostream& os, const Stonewt& s)
{
	if (s.mode == Stonewt::Mode::PDS)
		os << "Mode: PDS: " << s.pounds << " pounds";
	else if (s.mode == Stonewt::Mode::STN)
		os << "Mode: STN: " << s.stone << " stones, " << s.pds_left << "pounds";
	else if (s.mode == Stonewt::Mode::PDS_INT)
		os << "Mode: PDS_INT: " << s.pds_int << " pounds";
	else
		os << "The mode of Stonewt is wrong!";
	return os;
}




//main.cpp
#include<iostream>
#include"stonewt.h"
int main()
{
	using std::cout;
	using std::endl;
	Stonewt s1;
	Stonewt s2(321.123);
	Stonewt s3(10, 12.5);
	cout << s1 << endl << s2 << endl << s3 << endl;
	cout << "s2-s3= " << s2 - s3 << endl;
	cout << "s2+s3= " << s2 + s3 << endl;
	s1 = s3 * 13.5;
	cout << "s3*13.5= " << s1 << endl;
	s1 = 13.5 * s3;
	s1.mode_PDS_INT();
	cout << "13.5*s2= " << s1 << endl;
	s1.mode_STN();
	cout << "13.5*s2= " << s1 << endl;
	return 0;
}

practice 6

不能怪我懒，主要是抄代码实在太费时间了，所以直接用上一题的代码好了

贴太多代码看着都麻烦，所以只贴增加的一部分

//add to stonewt.h
    bool operator>(const Stonewt& s);
	bool operator>=(const Stonewt& s);
	bool operator<(const Stonewt& s);
	bool operator<=(const Stonewt& s);
	bool operator==(const Stonewt& s);
	bool operator!=(const Stonewt& s);




//add to stonewt.cpp
bool Stonewt::operator>(const Stonewt& s)
{
	if (pounds > s.pounds)
		return true;
	else return false;
}
bool Stonewt::operator>=(const Stonewt& s)
{
	if (pounds >= s.pounds)
		return true;
	else return false;
}
bool Stonewt::operator<(const Stonewt& s)
{
	if (pounds < s.pounds)
		return true;
	else return false;
}
bool Stonewt::operator<=(const Stonewt& s)
{
	if (pounds <= s.pounds)
		return true;
	else return false;
}
bool Stonewt::operator==(const Stonewt& s)
{
	if (pounds == s.pounds)
		return true;
	else return false;
}
bool Stonewt::operator!=(const Stonewt& s)
{
	if (pounds != s.pounds)
		return true;
	else return false;
}




//main.cpp
#include<iostream>
#include"stonewt.h"
int main()
{
	using std::cout;
	using std::cin;
	using std::endl;
	Stonewt arr_s[6] = { 12.3,14.5,17.8 };
	Stonewt standard(11);
	for (int i = 0; i < 3; i++) {
		cout << "Enter three number to construct Stonewt:\n";
		cout << "#" << i + 3 << ": ";
		double pds;
		cin >> pds;
		arr_s[i + 3] = Stonewt(pds);
	}
	for (int i = 0; i < 6; i++) {
		cout << "arr_s[" << i << "]: " << arr_s[i] << endl;
	}
	int max = 0;
	int min = 0;
	int n = 0;
	for (int i = 0; i < 6; i++) {
		if (arr_s[max] < arr_s[i])
			max = i;
		if (arr_s[min] > arr_s[i])
			min = i;
		if (arr_s[i] >= standard)
			n++;
	}
	cout << "The heaviest is arr_s[" << max << "]\n"
		<< "The lightest is arr_s[" << min << "]\n"
		<< "The number of Stonewts not ligther than 11 pounds is " << n << endl;
	return 0;
}

practice 7

这题我在自定义构造函数前没有用explicit，而且第二个参数是有默认参数，但是重载*的函数中2*c的函数我写了一个return c*2;   它不能自动转换，必须加（complex），就很奇怪，有没有懂的评论一下

//complex0.h
#pragma once//避免此头文件被包含多次，和#ifndef的作用类似
#ifndef COMPLEX0_H_
#define COMPLEX0_H_
#include<iostream>
class complex {
private:
	double real;
	double imaginary;
public:
	complex();
	complex(double rl, double imgnr = 0);
	complex operator+(const complex& c)const;
	complex operator-(const complex& c)const;
	complex operator*(const complex& c)const;
	complex operator~()const;
	friend complex operator*(double n,const complex& c);
	friend std::istream& operator>>(std::istream& os, complex& c);
	friend std::ostream& operator<<(std::ostream& os, const complex& c);
};
#endif



//complex0.cpp
#include"complex0.h"
complex::complex() {
	real = imaginary = 0.0;
}
complex::complex(double rl, double imgnr) {
	real = rl;
	imaginary = imgnr;
}
complex complex::operator+(const complex& c)const {
	complex sum;
	sum.real = real + c.real;
	sum.imaginary = imaginary + c.imaginary;
	return sum;
}
complex complex::operator-(const complex& c)const {
	complex sub;
	sub.real = real - c.real;
	sub.imaginary = imaginary - c.imaginary;
	return sub;
}
complex complex::operator*(const complex& c)const {
	complex mult;
	mult.real = real * c.real - imaginary * c.imaginary;
	mult.imaginary = real * c.imaginary + imaginary * c.real;
	return mult;
}
complex complex::operator~()const {
	complex conjugate;
	conjugate.real = real;
	conjugate.imaginary = imaginary;
	return conjugate;
}
complex operator*(double n, const complex& c) {
	return c * n;
}
std::istream& operator>>(std::istream& is, complex& c) {
	std::cout << "real: ";
	is >> c.real;
	if (is) {
		std::cout << "imaginary: ";
		is >> c.imaginary;
	}
	return is;
}
std::ostream& operator<<(std::ostream& os, const complex& c) {
	os << "(" << c.real << "," << c.imaginary << "i)";
	return os;
}



//main.cpp
#include<iostream>
#include"complex0.h"
int main() {
	using std::cout;
	complex a(3.0, 4.0);
	complex c;
	cout << "Enter a complex number (q to quit): \n";
	while (std::cin >> c)
	{
		cout << "c is " << c << '\n';
		cout << "complex  conjugate is " << ~c << '\n';
		cout << "a is " << a << '\n';
		cout << "a + c is " << a + c << '\n';
		cout << "a - c is " << a - c << '\n';
		cout << "a * c is " << a * c << '\n';
		cout << "2 * c is " << 2 * c << '\n';
		cout << "Enter a complex number (q to quit):\n";
	}
	cout << "Done!\n";
	return 0;
}

 为了搞清楚，我又双叒叕把（complex）去掉了，结果居然运行成功了

月731
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++ Primer Plus 编程练习源码工程 第11章
09-14
在本压缩包文件中，我们聚焦于"C++ Primer Plus"这本书的第11章编程练习。这是一份由用户LeonardoLiuwenbo在学习过程中编写的源代码工程，旨在帮助读者深入理解和应用C++语言。第11章通常涵盖C++中的高级主题，可能...
cpp11.3
rocvfx的博客
01-17 242
vector.h #pragma once #include namespace VECTOR { class Vector { public: enum Mode { RECT, POL }; private: double x; double y; double mag; double ang; Mode ang; void set_mag();
C++类的实例：一个向量类(Vector)
一只大鸽子的博客
07-19 1万+
 在数学中，向量（也称为欧几里得向量、几何向量、矢量），指具有大小和方向的量。 本例实现一个二维向量。 使用 直角坐标（x,y）和极坐标(a,m)表示。   /* (a为长度，m为角度)。*/
c++学习笔记--using（using std::cout；）
最新发布
Cavendix的博客
05-15 449
这段代码是一个using声明，它将Camera类中的setVideoQuality函数引入到当前作用域中，以便可以在不需要使用Camera作为前缀的情况下使用该函数。在这个例子中，我们使用"using"关键字将"cout"、"endl"和"sqrt"符号从它们各自的命名空间中引入到我们当前的作用域中。注意，在这种情况下，我们需要传递Camera对象作为函数的第一个参数。C++中的"using"关键字用于将一个符号引入到当前的作用域中，以便可以在不需要使用其命名空间限定符的情况下使用它。
【1058】求一元二次方程
LWX3289765163的博客
10-31 440
分析： 因为a不为0，所以可能的情况少了很多。 问题在于：判断是否为0 上，由于double类型存在缺陷（计算机的原因吧），无法准确的表示0，因此只能表示无限趋于0，当一个double值的小数位数过多时，就会不够精准，只能将其和一个比较趋于0的小数进行比较，进而认为他“就是”0. fabs():用来取double类型数据的绝对值 #include<iostream> #include<cmath> #include<iomanip> using st...
C++问题，对象包含与成员函数不兼容的类型限定符
wonengguwozai的博客
07-19 1万+
在编写Image 的构造函数时： Image::Image(const Matrix &m) //构造函数重载，由Matrix类对象构造Image类对象（Matrix类是image类的父类） { height=m.Height(); } 其中Height()是Matrix 类的成员函数，返回矩阵的高； 标红的m.Height();提示 ：  Error 对象包含与成员函数不
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
c++primer plus第七章到第十三章习题源码
03-12
《C++ Primer Plus》是C++编程领域里一本经典的教程，涵盖了从基础语法到高级特性的广泛内容。从第七章到第十三章，这涵盖了类（classes）、对象（objects）、继承（inheritance）、多态（polymorphism）、模板...
C++ primer plus课后编程练习题答案
04-22
第十一章继续深入讲解了类和对象的使用，包括类的多态、类的继承、类的组合等，提供了相关的编程练习题和答案，帮助读者掌握类和对象的高级使用技巧。第十六章和第十七章讲解了高级主题，包括模板、异常处理、输入/...
“随机漫步”(Random Walk)模拟演示
Andrew Shaw|失的猛
07-16 1万+
(1)、任务描述 有一类问题总称为“随机漫步”(Random Walk)问题，这类问题长久以来吸引着数学界的兴趣。所有这些问题即使是最简单的解决起来也是极其困难的。而且它们在很大程度上还远没有得到解决。一个这样的问题可以描述为： 在矩形的房间里，铺有n×m块瓷砖，现将一只（醉酒的）蟑螂放在地板中间一个指定方格里。蟑螂随机地从一块瓷砖“漫步”到另一块瓷砖（可能是在找一片阿司匹林）。假设它可能从
Random Walk.c（随机数）
weixin_45454859的博客
10-26 749
随机漫步 题目： 1.r （1）作用：c语言中，产生随机数 （2）使用： 产生一个0的
sqrt函数
behboyhiex的博客
09-24 1651
给定x，求sqrt(x) 不允许调用系统sqrt()函数 方法一：牛顿迭代 #include&lt;bits/stdc++.h&gt; using namespace std; float SqrtByNewton(float x,float eps){ float val=x; float last=x/2; while((abs(last*last-val)&gt;eps){ ...
C++ Primer Plus（第六版）第十一章课后习题
Francis_U的博客
01-08 220
C++ Primer Plus（第六版）第三章课后习题 3.7.1 #include int main() { using namespace std; double height; const int change=12; int foot, inch; cout <<“Please enter your height:_______\b\b\b\b\b\b\b” ; cin &g...
C++中cos,sin,asin,acos这些三角函数操作
要做ADC
08-12 6万+
C++中cos,sin,asin,acos这些三角函数操作的是弧度,而非角度, 你需要把角度转化为弧度. 弧度=角度*Pi/180; 例子1： 比如对边和邻边分别为a,b  设角度为x，则  x=atan(a/b);  其中x为弧度制  如需转换为角度值，则x*180/3.1415 例子2： //计算旋转角度   {弧度=角度*Pi/180} {两点间距离公式
ATan2与ATan的区别
weixin_34234721的博客
02-15 1261
相比较ATan，ATan2究竟有什么不同？本篇介绍一下ATan2的用法及使用条件。 对于tan(θ) = y / x: θ = ATan(y / x)求出的θ取值范围是[-PI/2, PI/2]。 θ = ATan2(y, x)求出的θ取值范围是[-PI, PI]。 当 (x, y) 在第一象限, 0 &lt; θ &lt; PI/2. 当 (x, y) 在第二象限 PI...
C++中反正切atan2(y,x)与atan(x)
热门推荐
chen825919148的专栏
05-19 8万+
1、atan（x）表示求的是x的反正切，其返回值为[-pi/2,+pi/2]之间的一个数。 2、atan2（y，x）求的是y/x的反正切，其返回值为[-pi,+pi]之间的一个数。 atan2返回值解释： 在三角函数中，两个参数的函数atan2是正切函数的一个变种。对于任意不同时等于0的实参数x和y，atan2(y,x)所表达的意思是坐标原点为起点，指向(y,x)的射线在坐标平面上与x轴正方
C++11命名空间的using说明
CHYabc123456hh的博客
10-04 216
std::cin 表示从标准输入读取内容，此处的作用域操作符::是指编译器应该从左侧名字所示的作用域中寻找右侧那个名字。因此std::sin表示使用命名空间std中的cin。 每个名字都需要有独立的using的声明 每一个using声明引入命名空间中的一个成员，比如可以将要用到的标准库中的名字都以using声明的形式表示出来。 using std::cin; using std::cout; using std::endl; 头文件不应包含using声明 因为头文件的内容会被拷贝到所有引用它的文件
C++ Primer Plus Sixth Edition
03-09
"C++ Primer Plus Sixth Edition 是一本英文的第六版C++编程教程，由Stephen Prata撰写。这本书是Developer's Library系列的一部分，该系列专为编程专业人士提供关键的参考资料和教程，涵盖他们日常工作中使用的编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值