【学习C++】C++ Primer Plus （第六版）第十一章编程练习1-7

最新推荐文章于 2017-03-04 23:01:43 发布
最新推荐文章于 2017-03-04 23:01:43 发布
阅读量572 收藏
点赞数
分类专栏： 学习C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujiayu1015/article/details/51463876
版权

1.

vector.h和vector.cpp见书 程序清单11.13,11.14

//main.cpp
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <ctime>
#include "vector.h"
int main(){
	using namespace std;
	srand(time(0));
	double direction;
	Vector step;
	Vector result(0.0, 0.0);
	unsigned long steps = 0;
	double target;
	double dstep;
	ofstream fout;
	fout.open("the walk.txt");
	cout << "Enter target distance (q to quit):";
	while (cin >> target){
		cout << "Enter step length:";
		if (!(cin >> dstep))
			break;
		fout << "Target Distance: " << target << ", Step Size: " << dstep<<"\n";
		fout << steps << ": (x,y) = " << result << "\n";
		while (result.magval() < target){
			direction = rand() % 360;
			step.reset(dstep, direction, Vector::POL);
			result = result + step;
			steps++;
			fout << steps << ": (x,y) = " << result << "\n";
		}
		fout << "After " << steps << " steps, the subject has the following location:\n";
		fout << result << endl;
		result.polar_mode();
		fout << " or\n" << result << endl;
		fout << "Average outward distance per step = " << result.magval() / steps << endl;
		steps = 0;
		result.reset(0.0, 0.0);
		cout << "Enter target distance (q to quit): ";
	}
	cout << "Bye!\n";
	cin.clear();
	while (cin.get() != '\n')
		continue;
	cin.get();
	return 0;
}

2.

//vector.h
#ifndef VECTOR_H_
#define VECTOR_H_
#include<iostream>
using namespace std;
class Vector{
public:
	enum Mode {RECT,POL};
private:
	double x;
	double y;
	Mode mode;
public:
	Vector();
	Vector(double n1, double n2, Mode form = RECT);
	void reset(double n1, double n2, Mode form = RECT);
	~Vector();
	double xval() const { return x; }
	double yval() const { return y; }
	double magval() const;
	double angval() const;
	void polar_mode();
	void rect_mode();
	Vector operator+(const Vector & b) const;
	Vector operator-(const Vector & b) const;
	Vector operator-() const;
	Vector operator*(double n) const;
	friend Vector operator*(double n, const Vector & a);
	friend ostream & operator<<(ostream & os, const Vector & v);
};
#endif
//vector.cpp
#include<iostream>
#include <cmath>
#include "vector.h"
using namespace std;
const double Rad_to_deg = 45.0 / atan(1.0);
Vector::Vector(){
	x = y = 0.0;
	mode = RECT;
}
Vector::Vector(double n1, double n2, Mode form){
	mode = form;
	if (form == RECT){
		x = n1;
		y = n2;
	}
	else if (form == POL){
		x = n1*cos(n2 / Rad_to_deg);
		y = n1*sin(n2 / Rad_to_deg);
	}
	else{
		cout << "Incorrect 3rd argument to Vector() -- ";
		cout << "vector set to 0\n";
		x = y = 0.0;
		mode = RECT;
	}
}
void Vector::reset(double n1, double n2, Mode form)
{
	mode = form;
	if (form == RECT)
	{
		x = n1;
		y = n2;
	}
	else if (form == POL){
		x = n1*cos(n2 / Rad_to_deg);
		y = n1*sin(n2 / Rad_to_deg);
	}
	else{
		cout << "Incorrect 3rd argument to Vector() -- ";
		cout << "vector set to 0\n";
		x = y = 0.0;
		mode = RECT;
	}
}
Vector::~Vector()
{
}
double Vector::magval() const{
	return sqrt(x*x+ y*y);
}
double Vector::angval() const{
	if (x == 0.0&&y == 0.0)
		return 0.0;
	else
		return atan2(y, x);

}
void Vector::polar_mode(){
	mode = POL;
}
void Vector::rect_mode(){
	mode = RECT;
}
Vector Vector::operator+(const Vector & b) const{
	return Vector(x + b.x, y + b.y);
}
Vector Vector::operator-(const Vector & b) const{
	return Vector(x - b.x, y - b.y);
}
Vector Vector::operator-() const{
	return Vector(-x, -y);
}
Vector Vector::operator*(double n) const{
	return Vector(n*x,n*y);
}
Vector operator*(double n, const Vector & a){
	return a*n;
}
ostream & operator<<(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.magval() << "," << v.angval()*Rad_to_deg << ")";
	}
	else
		os << "Vector object mode is invalid";
	return os;
}
//main.cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "vector.h"
int main(){
	using namespace std;
	srand(time(0));
	double direction;
	Vector step;
	Vector result(0.0, 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, 0.0);
		cout << "Enter target distance (q to quit): ";
	}
	cout << "Bye!\n";
	cin.clear();
	while (cin.get() != '\n')
		continue;
	cin.get();
	return 0;
}

3.

vector.h和vector.cpp见书 程序清单11.13,11.14

//main.cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "vector.h"
int main(){
	using namespace std;
	srand(time(0));
	double direction;
	Vector step;
	Vector result(0.0, 0.0);
	unsigned long steps = 0;
	double target;
	double dstep;
	int N;
	cout << "Enter times of our test:";
	cin >> N;
	int minsteps, maxsteps = 0,sumsteps=0;
	for (int i = 0; i < N; i++){
		cout << "Enter target distance (q to quit):";
		cin >> target;
		cout << "Enter step length:";
		cin >> dstep;
		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;
		if (i == 0)
			minsteps = steps;
		else if (minsteps > steps)
			minsteps = steps;
		else
			;
		if (steps > maxsteps)
			maxsteps = steps;
		sumsteps += steps;
		cout << "Average outward distance per step = " << result.magval() / steps << endl;
		steps = 0;
		result.reset(0.0, 0.0);
	}
	cout << "Max steps: " << maxsteps << endl;
	cout << "Min steps: " << minsteps << endl;
	cout << "Everage steps:" << sumsteps / N << endl;
	cout << "Bye!\n";
	while (cin.get() != '\n')
		continue;
	cin.get();
	return 0;
}

4.

//time.h
#ifndef TIME_H_
#define TIME_H_
#include<iostream>
using namespace std;
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*(double n, const Time & t);
	friend Time operator*(const Time & t, double n);
	friend ostream & operator<<(ostream & os, const Time & t);

};
#endif
//time.cpp
#include<iostream>
#include "time.h"
using namespace std;
Time::Time(){
	hours = minutes = 0;
}
Time::Time(int h, int m){
	hours = h;
	minutes = m;
}
void Time::AddMin(int m){
	minutes += m;
	minutes = minutes % 60;
	hours += 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 sum;
	sum.minutes = t1.minutes + t2.minutes;
	sum.hours = t1.hours + t2.hours + sum.minutes / 60;
	sum.minutes %= 60;
	return sum;
}
Time operator-(const Time & t1, const Time & t2){
	Time diff;
	int tot1, tot2;
	tot1 = t1.minutes + t2.hours * 60;
	tot2 = t2.minutes + t2.hours * 60;
	diff.minutes = (tot1 - tot2) % 60;
	diff.hours = (tot1 - tot2) / 60;
	return diff;
}
Time operator*(double n, const Time & t){
	Time result;
	long total = (t.minutes + t.hours * 60)*n;
	result.hours = total / 60;
	result.minutes = total % 60;
	return result;
}
Time operator*(const Time & t, double n){
	return n*t;
}
ostream & operator<<(ostream & os, const Time & t){
	os << t.hours << " hours, " << t.minutes << " minutes";
	return os;
}
//main.cpp
#include <iostream>
#include "time.h"
using namespace std;
int main(){
	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*Tosca: " << 10.0*tosca << endl;
	cin.get();
	cin.get();
	return 0;
}

5.

//stonewt.h
#ifndef STONEWT_H_
#define STONEWT_H_
#include<iostream>
using namespace std;
class Stonewt
{
public:
	enum Mode{ Stone, int_p, double_p };
private:
	enum { Lbs_per_stn = 14 };
	int stone;
	double pds_left;
	double pounds;
	Mode mode;
public:
	Stonewt(double lbs);
	Stonewt(int stn, double lbs);
	Stonewt();
	~Stonewt();
	void set_mode(Mode m);
	Stonewt operator+(const Stonewt & s) const;
	Stonewt operator-(const Stonewt & s) const;
	Stonewt operator*(const Stonewt & s) const;
	friend ostream & operator<<(ostream & os, const Stonewt & s);
};
#endif
//stonewt.cpp
#include<iostream>
#include "stonewt.h"
using namespace std;
Stonewt::Stonewt(double lbs){
	stone = (int)lbs / Lbs_per_stn;
	pds_left = (int)lbs%Lbs_per_stn+lbs-(int)lbs;
	pounds = lbs;
	mode = double_p;
}
Stonewt::Stonewt(int stn, double lbs){
	stone = stn;
	pds_left = lbs;
	pounds = stn*Lbs_per_stn + lbs;
	mode = Stone;
}
Stonewt::Stonewt(){
	stone = pounds = pds_left = 0;
	mode = double_p;
};
Stonewt::~Stonewt(){
}
void Stonewt::set_mode(Mode m){
	mode = m;
}
Stonewt Stonewt::operator+(const Stonewt & s) const{
	return Stonewt(pounds + s.pounds);
}
Stonewt Stonewt::operator-(const Stonewt & s) const{
	return Stonewt(pounds - s.pounds);
}
Stonewt Stonewt::operator*(const Stonewt & s) const{
	return Stonewt(pounds * s.pounds);
}
ostream & operator<<(ostream & os, const Stonewt & s){
	if (s.mode == Stonewt::Stone)
		os << s.stone << " stone, " << s.pds_left << " pounds\n";
	if (s.mode == Stonewt::double_p)
		os << s.pounds << " pounds\n";
	if (s.mode == Stonewt::int_p)
		os << (int) s.pounds << " pounds\n";
	return os;
}

//main.cpp
#include <iostream>
#include "stonewt.h"
using namespace std;
int main(){
	Stonewt s1(12, 0);
	Stonewt s2(145.2);
	Stonewt s3 = s1 + s2;
	cout << "s3 = " << s3 << endl;
	s3.set_mode(Stonewt::Stone);
	cout << "(stone) s3 = " << s3 << endl;
	s3.set_mode(Stonewt::int_p);
	cout << "(int) s3 = " << s3 << endl;
	cout << "s1 - s2 = " << s1 - s2 << endl;
	cout << "s1 * s2 = " << s1*s2 << endl;
	cin.get();
	cin.get();
	return 0;
}

6.

//stonewt.h
#ifndef STONEWT_H_
#define STONEWT_H_
class Stonewt
{
private:
	enum { Lbs_per_stn = 14 };
	int stone;
	double pds_left;
	double pounds;
public:
	Stonewt(double lbs);
	Stonewt(int stn, double lbs);
	Stonewt();
	~Stonewt();
	void show_lbs() const;
	void show_stn() const;
	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);

};
#endif
//stonewt.cpp
#include<iostream>
#include "stonewt.h"
using namespace std;
Stonewt::Stonewt(double lbs){
	stone = (int)lbs / Lbs_per_stn;
	pds_left = (int)lbs%Lbs_per_stn+lbs-(int)lbs;
	pounds = lbs;
}
Stonewt::Stonewt(int stn, double lbs){
	stone = stn;
	pds_left = lbs;
	pounds = stn*Lbs_per_stn + lbs;
}
Stonewt::Stonewt(){
	stone = pounds = pds_left = 0;
};
Stonewt::~Stonewt(){
}
void Stonewt::show_stn() const{
	cout << stone << " stone, " << pds_left << "pounds\n";
}
void Stonewt::show_lbs() const{
	cout << pounds << " pounds\n";
}
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"
using namespace std;
int main(){
	Stonewt s[6] = {Stonewt(11,0),Stonewt(15,1),Stonewt(16,1)};
	int p;
	double l;
	for (int i = 3; i < 6; i++){
		cout << "please initialize Stonewt[" << i << "]: ";
		cin >> p;
		cin >> l;
		s[i]=Stonewt(p,l);
	}
	Stonewt mins=s[0],maxs=s[0];
	Stonewt ele(11, 0);
	int num = 0;
	int min=0, max = 0;
	for (int i = 0; i < 6; i++){
		if (s[i] < mins){
			mins = s[i];
			min = i;
		}
		if (s[i] > maxs){
			maxs = s[i];
			max = i;
		}
		if (s[i] >= ele)
			num++;
	}
	cout << "s[ " << min << "] is the smallest element"<<endl;
	s[min].show_lbs();
	cout << "s[ " << max << "] is the bigest element" << endl;
	s[max].show_lbs();
	cout << "number :" << num << endl;
	cin.get();
	cin.get();
	return 0;
}

7.

//complex0.h
#ifndef COMPLEX0_H_
#define COMPLEX0_H_
#include <iostream>
using namespace std;
class complex{
private:
	double real;
	double ima;
public:
	complex(double r = 0, double m = 0);
	complex operator+(const complex & a) const;
	complex operator-(const complex & a) const;
	complex operator*(const complex & a) const;
	friend complex operator~(const complex & a);
	friend complex operator*(double x, const complex & c);
	friend ostream & operator<<(ostream & os, complex & c);
	friend istream & operator>>(istream & is, complex &c);
};
#endif
//complex.cpp
#include "complex0.h"
complex::complex(double r, double m){
	real = r;
	ima = m;
}
complex complex::operator+(const complex & a) const{
	complex sum;
	sum.real = real + a.real;
	sum.ima = ima + a.ima;
	return sum;
}
complex complex::operator-(const complex & a) const{
	complex dif;
	dif.real = real - a.real;
	dif.ima = ima - a.ima;
	return dif;
}
complex complex::operator*(const complex & a) const{
	complex result;
	result.real = real*a.real - ima*a.ima;
	result.ima = real*a.ima + ima*a.real;
	return result;
}
complex operator*(double x, const complex & c){
	complex result;
	result.real = x*c.real;
	result.ima = x*c.ima;
	return result;
}
ostream & operator<<(ostream & os, complex & c){
	os << "(" << c.real << "," << c.ima << "i)";
	return os;
}
istream & operator>>(istream & is, complex &c){
	cout << "real: ";
	is >> c.real;
	cout << "imaginary: ";
	is >> c.ima;
	return is;
}
complex operator~(const complex & a){
	complex g;
	g.real = a.real;
	g.ima = -a.ima;
	return g;

}
//main.cpp
#include <iostream>
#include "complex0.h"
using namespace std;
int main(){
	complex a(3.0, 4.0);
	complex c;
	cout << "Enter a complex number (q to quit):\n";
	while (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;
}

牛遛遛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++-primer-plus(第6版)中文版-编程练习答案(word版).pdf
01-20
C++ Primer Plus第6版中文版编程练习答案 本资源为C++ Primer Plus第6版中文版编程练习答案，涵盖了C++基础知识的多个方面，包括基本语法、数据类型、函数、输入输出等。 在第二章中，主要介绍了C++的基本语法和...
C++ Primer Plus 第六版 第6版 中文版 编程练习答案
08-17
C++ Primer Plus 第六版 第6版 中文版 编程练习答案 全面详细，助力深入理解C++精髓
c++-primer-plus(第六版)-编程练习答案
04-18
### C++ Primer Plus (第六版) - 编程练习答案解析 #### 第二章：开始学习C++ 在第二章中，我们通过几个简单的程序来熟悉C++的基本语法和概念。 ##### 2.1 显示姓名和地址 **知识点：** 1. **基本输出**：使用`...
C++ Primer Plus 第6版 中文版课后代码习题答案
最新发布
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
【学习C++】2.cin与Enter
牛遛遛
03-26 1048
今天看书的时候突然想明白了从键盘输入信息然后发送到程序时怎样的一个过程，之前一直想不明白，在此记录一下我的想法。     首先看一个程序：#include int main（） { using namespace std; char ch; int count=0; cout << "Enter characters; enter
【学习C++】C++ Primer Plus （第六版）第十章编程练习1-8
牛遛遛
05-06 950
1.#include #include class Account{ private: std::string name; std::string number; double deposit; public: Account(const std::string & na="no name",const std::string & nu="0",int de=0); void sho
【学习C++】C++ Primer Plus （第六版）第十二章编程练习1-6
牛遛遛
06-01 464
1.//cow.h #ifndef COW_H_ #define COW_H_ #include using namespace std; class Cow { char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * nm, const char * ho, double wt); Co
2017.02.29 C/C++小知识点
牛遛遛
03-01 410
1. 函数重载： 指的是在同一作用域内，可以有一组相同函数名，不同参数列表的函数，这组函数被称为重载函数。通常用来命名一组功能相似的函数，减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处，方便用户使用。 2.main函数中如果无return，编译器会自动添加 return 0； 3. math.h中的abs函数的返回值：当num为最小负数时，abs(num)依然返回该最小
2017.03.04 C/C++小知识点
牛遛遛
03-04 376
1. struct成员类型不可以是它自己，因为会递归定义，理论上导致结构体的大小不能被计算。但是成员可以定义为该结构体的指针或引用。 2. sizeof('0')在C语言里，存放的是字符的ASCALL码（整型数据），结果为4，在C++中，‘0’为字符常量，类型为char，结果为1. 3. 数组初始化规则：如果制定了数组维数，那么初始化列表提供的元素个数不能超过维数值。如果维数大于列出的元素初始
2017.03.02 C/C++小知识点
牛遛遛
03-02 372
1. read是Unix系统的库函数，而fread才是C中的库函数。read属于系统调用，从打开的设备或文件中读取数据。 2. int a=1,b=32. 当执行a 3. ifndef/define/endif 的含义：如果未定义/那么定义/完成假设 一般是用来防止头文件被重复包含，提高编译效率的。 4. 字符'\0'的ASCALL码值为0 5. 结构和联合都是有多个不同的数据类型成员组成
2017.03.03 C/C++小知识点
牛遛遛
03-03 356
1. int arr(5)  表明声明一个变量arr，其初始值为5. 2. C++里面的函数可以嵌套调用，但不可以嵌套定义。 3. x86的机器上是小端存出。 4. 全局对象的生命周期跨越这个程序运行期间，在main函数调用之前创建，在main函数结束之后，程序结束之前析构。 5. (int &) a告诉编译器将a当成int对待（不做任何转换）。将a里面存储的值当成int类型的值。 6.
【学习C++】C++ Primer Plus （第六版）第九章编程练习1-4
牛遛遛
04-27 337
1.//golf.h const int Len = 40; struct golf { char fullname[Len]; int handicap; }; void setgolf(golf & g, const char * name, int hc); int setgolf(golf & g); void handicap(golf & g, int hc); void show
【学习C++】1.开始学习C++
牛遛遛
03-05 319
从今天开始学习C++，争取一年之内把《C++ Primer Plus》看上两遍，平均一周看一章，并做课后对应习题。 今天把《C++ Primer Plus》的第二章看完了，因为只是一些涉及到C语言和C++的简单的基础知识，所以看的速度非常快，一下午加一晚上就把书仔细的看了一遍，并将课后习题做了一下。虽然内容很简单，但还是得到了一些新的东西。下面将今天看的需要注意的基本点总结一下。 本章主要讲了
【学习C++】C++ Primer Plus （第六版）第七章编程练习6-10
牛遛遛
04-16 319
6.#include using namespace std; int Fill_array(double [], int size); void Show_array(double [], int size); void Reverse_array(double [], int size); int main() { int size,rsize; cin >> size; doubl
【学习C++】3.构造函数
牛遛遛
05-04 302
在C++中，程序在声明一个类的对象时，自动调用构造函数。在构造函数创造出对象之前，对象是不存在的，构造函数的作用是创造对象，所以称之为构造函数。构造函数是不能通过对象来调用的。 构造函数的创建     构造函数需要由程序员来创建，具体的声明与定义方法与类中的成员函数的声明与定义方法相同，但是需要注意构造函数的名称与类名相同。假设Stock是程序员定义的一个类，则在Stock的类声明中对构造函数
【学习C++】C++ Primer Plus （第六版）第八章编程练习1-7
牛遛遛
04-22 295
1.#include #include using namespace std; void priStr(char *); void priStr(char *, int n); static int i = 1; int main() { char a[10] = "liujiayu"; priStr(a); for (int i = 1; i < 4; i++){ priStr(
2017.02.28 C/C++小知识点
牛遛遛
02-28 278
1.赋值语句的返回值是所赋的值。所以在C/C++中才会有如下的连续赋值语句 a=b=10  即b=10这个赋值语句的返回值是10. 2.在32位机器上，int类型占4个字节，枚举类型同int类型，占4个字节。typedef只是一个声明，不占空间。空函数不占空间。 3.在结构struct中，各成员有个字的内存空间，一个结构变量的总长度是各成员长度之和。而在联合体union中，各成员共享一段内存空
【学习C++】C++ Primer Plus （第六版）第十三章编程练习1-4
牛遛遛
06-07 242
1. //classic.h #ifndef CLASSIC_H_ #define CLASSIC_H_ class Cd{ private: char performers[50]; char label[20]; int selections; double playtime; public: Cd(char * s1, char * s2, int n, double x);
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值