【C++初学】课后作业汇总复习（七） 指针-深浅copy

1、 HugeInt类:构造、+、cout

Description:
32位整数的盘算机可以表现整数的范围近似为－20亿到＋20亿。在这个范围内使用一样寻常不会出现标题，但是有的应用步调大概须要使用超出上述范围的整数。C++可以满足这个需求，创建功能强盛的新的数据范例。
界说一个HugeInt类，使用一个数组存储大整数的每一位。如 short integer[ 40 ]; 即可实现存储位数为40位的整数。暂不思量负数。请根据主函数为该类：
1）界说两个构造，分别继承int和string范例的参数；当参数为string范例时，可以使用字符串处理处罚函数将string范例转换为数值范例。
2）重载＋运算，分别可以大概实现两个HugeInt对象相加，HugeInt与int相加，HugeInt与string相加。提示，先实现两个HugeInt相加，当HugeInt与int相加时，可以将int通过转换构造函数转换为HugeInt范例，然后调用两个HugeInt相加。HugeInt与string相加亦云云。
3）重载<<运算符。
注意：步调前缀、后缀代码已给出。
Sample Input：
无
Sample Output：

1. //StudybarCommentBegin
2. #include <iostream>
3. #include <cctype> // isdigit function prototype
4. #include <cstring> // strlen function prototype
5. using namespace std;
7. class HugeInt
8. {
9.     friend ostream &operator<<( ostream &, const HugeInt & );
10. public:
11.     static const int digits = 30;
12.     HugeInt( long = 0 ); // conversion/default constructor
13.     HugeInt( const char * ); // conversion constructor
14.    
15.     // addition operator; HugeInt + HugeInt
16.     HugeInt operator+( const HugeInt & ) const;
17.    
18.     // addition operator; HugeInt + int
19.     HugeInt operator+( int ) const;
20.    
21.     // addition operator;
22.     // HugeInt + string that represents large integer value
23.     HugeInt operator+( const char * ) const;
24.    
25.     int getLength() const;
26. private:
27.     short integer[ digits ];
28. }; // end class HugeInt
30. //StudybarCommentEnd
32. // Implementation of HugeInt class
33. HugeInt::HugeInt(long value) {
34.     // Initialize all digits to 0
35.     for (int i = 0; i < digits; i++) {
36.         integer[i] = 0;
37.     }
38.    
39.     // Store digits in reverse order
40.     for (int i = digits - 1; value != 0 && i >= 0; i--) {
41.         integer[i] = value % 10;
42.         value /= 10;
43.     }
44. }
46. HugeInt::HugeInt(const char *str) {
47.     // Initialize all digits to 0
48.     for (int i = 0; i < digits; i++) {
49.         integer[i] = 0;
50.     }
51.    
52.     int len = strlen(str);
53.     int j = digits - 1;
54.    
55.     // Store digits in reverse order
56.     for (int i = len - 1; i >= 0 && j >= 0; i--) {
57.         if (isdigit(str[i])) {
58.             integer[j--] = str[i] - '0';
59.         }
60.     }
61. }
63. HugeInt HugeInt::operator+(const HugeInt &op2) const {
64.     HugeInt temp;
65.     int carry = 0;
66.    
67.     for (int i = digits - 1; i >= 0; i--) {
68.         temp.integer[i] = integer[i] + op2.integer[i] + carry;
69.         
70.         if (temp.integer[i] > 9) {
71.             temp.integer[i] %= 10;
72.             carry = 1;
73.         } else {
74.             carry = 0;
75.         }
76.     }
77.    
78.     return temp;
79. }
81. HugeInt HugeInt::operator+(int op2) const {
82.     return *this + HugeInt(op2);
83. }
85. HugeInt HugeInt::operator+(const char *op2) const {
86.     return *this + HugeInt(op2);
87. }
89. int HugeInt::getLength() const {
90.     int i;
91.     for (i = 0; (i < digits) && (integer[i] == 0); i++)
92.         ; // skip leading zeros
93.    
94.     return (i == digits) ? 1 : (digits - i);
95. }
97. ostream &operator<<(ostream &output, const HugeInt &num) {
98.     int i;
99.     for (i = 0; (i < HugeInt::digits) && (num.integer[i] == 0); i++)
100.         ; // skip leading zeros
101.    
102.     if (i == HugeInt::digits) {
103.         output << 0;
104.     } else {
105.         for (; i < HugeInt::digits; i++) {
106.             output << num.integer[i];
107.         }
108.     }
109.    
110.     return output;
111. }
113. //StudybarCommentBegin
114. int main()
115. {
116.     HugeInt n1( 7654321 );
117.     HugeInt n2( 7891234 );
118.     HugeInt n3( "99999999999999999999999999999" );
119.     HugeInt n4( "1" );
120.     HugeInt result;
121.    
122.     cout << "n1 is " << n1 << "\nn2 is " << n2
123.     << "\nn3 is " << n3 << "\nn4 is " << n4
124.     << "\nresult is " << result << "\n\n";
125.    
126.    
127.     result = n1 + n2;
128.     cout << n1 << " + " << n2 << " = " << result << "\n\n";
129.    
130.     cout << n3 << " + " << n4 << "\n= " << ( n3 + n4 ) << "\n\n";
131.    
132.     result = n1 + 9;
133.     cout << n1 << " + " << 9 << " = " << result << endl;
134.    
135.     result = n2 + "10000";
136.     cout << n2 << " + " << "10000" << " = " << result << endl;
137.     return 0;
138. } // end main
140. //StudybarCommentEnd

复制代码

2、对象指针界讨情势——代码改正

对象指针界讨情势
类名 *对象指针名；
例:
Point a(5,10);
Piont *ptr;
ptr=&a;
通过指针访问对象成员
对象指针名->成员名
例：ptr->getx() 相称于 (*ptr).getx();
例6-12使用指针来访问Point类的成员
//6_12.cpp
#include
using namespace std;
class Point {
public:
Point(int x = 0, int y = 0) : x(x), y(y) { }
int getX() const { return this->x; }
int getY() const { return  y; }
private:
int x, y;
};
int main() {
Point a(4, 5);
Point  p1 = &a; //界说对象指针，用a的所在初始化
cout << p1.getX() << endl;//用指针访问对象成员
cout << a->getY() << endl; //用对象名访问对象成员
return 0;
}
本题输出结果
4
5

1. #include <iostream>
2. using namespace std;
4. class Point {
5. public:
6.     Point(int x = 0, int y = 0) : x(x), y(y) { }
7.     int getX() const { return this->x; }
8.     int getY() const { return y; }
9. private:
10.     int x, y;
11. };
13. int main() {
14.     Point a(4, 5);
15.     Point *p1 = &a; // 定义对象指针，用a的地址初始化
16.     cout << p1->getX() << endl; // 用指针访问对象成员
17.     cout << a.getY() << endl; // 用对象名访问对象成员
18.     return 0;
19. }

复制代码

3、动态创建对象举例

动态内存分配
动态申请内存使用符 new
new 范例名T（初始化参数列表）
功能：在步调实验期间，申请用于存放T范例对象的内存空间，并依初值列表赋以初值。
结果值：乐成：T范例的指针，指向新分配的内存；失败：抛出非常。
开释内存使用符delete
delete 指针p
功能：开释指针p所指向的内存。p必须是new使用的返回值。
本题给出了前缀，本题步调，应该和下列代码等价！
例6-16 动态创建对象举例
#include
using namespace std;
class Point {
public:
Point() : x(0), y(0) {
cout<<“Default Constructor called.”<<endl;
}
Point(int x, int y) : x(x), y(y) {
cout<< “Constructor called.”<<endl;
}
~Point() { cout<<“Destructor called.”<<endl; }
int getX() const { return x; }
int getY() const { return y; }
void move(int newX, int newY) {
x = newX;
y = newY;
}
private:
int x, y;
};
int main() {
cout << "Step one: " << endl;
Point *ptr1 = new Point; //调用默认构造函数
cout<getX()<<endl; //输出GetX
delete ptr1; //删除对象，主动调用析构函数
cout << "Step two: " << endl;
ptr1 = new Point(1,2);
cout<getX()<<endl; //输出GetX
delete ptr1;
return 0;
}

1. //StudybarCommentBegin
2. #include <iostream>
3. using namespace std;
4. class Point {
5. public:
6.         Point();
7.         Point(int x, int y);
8.         ~Point();
9.         int getX() const;
10.         int getY() const;
11.         void move(int newX, int newY);
12. private:
13.         int x, y;
14. };
15. //StudybarCommentEnd
17. Point::Point() : x(0), y(0) {
18.     cout << "Default Constructor called." << endl;
19. }
21. Point::Point(int x, int y) : x(x), y(y) {
22.     cout << "Constructor called." << endl;
23. }
25. Point::~Point() {
26.     cout << "Destructor called." << endl;
27. }
29. int Point::getX() const {
30.     return x;
31. }
33. int Point::getY() const {
34.     return y;
35. }
37. void Point::move(int newX, int newY) {
38.     x = newX;
39.     y = newY;
40. }
42. int main() {
43.     cout << "Step one: " << endl;
44.     Point *ptr1 = new Point; //调用默认构造函数
45.     cout << ptr1->getX() << endl; //输出GetX
46.     delete ptr1; //删除对象，自动调用析构函数
47.     cout << "Step two: " << endl;
48.     ptr1 = new Point(1,2);
49.     cout << ptr1->getX() << endl; //输出GetX
50.     delete ptr1;
51.     return 0;
52. }

复制代码

4、 动态创建对象数组举例

例6-17 动态创建对象数组举例
分配和开释动态数组
分配：new 范例名T [ 数组长度 ]
数组长度可以是任何表达式，在运行时盘算
开释：delete[] 数组名p
开释指针p所指向的数组。
p必须是用new分配得到的数组首所在。
例6-17 动态创建对象数组举例

1. #include<iostream>
3. using namespace std;
5. #include <iostream>
7. using namespace std;
9. class Point {
11. public:
13. Point() : x(0), y(0) {
15. cout<<"Default Constructor called."<<endl;
17. }
19. Point(int x, int y) : x(x), y(y) {
21. cout<< "Constructor called."<<endl;
23. }
25. ~Point() { cout<<"Destructor called."<<endl; }
27. int getX() const { return x; }
29. int getY() const { return y; }
31. void move(int newX, int newY) {
33. x = newX;
35. y = newY;
37. }
39. private:
41. int x, y;
43. };
45. int main() {
46. Point *ptr = new Point[2]; //创建对象数组
47. ptr[0].move(5, 10); //通过指针访问数组元素的成员
48. cout<<ptr[0].getY()<<endl;
49. ptr[1].move(15, 20); //通过指针访问数组元素的成员
50. cout<<ptr[1].getY()<<endl;   
51. cout << "Deleting..." << endl;
52. delete[] ptr; //删除整个对象数组
53. return 0;
54. }

复制代码

5、浅层复制与深层复制

浅层复制
实现对象间数据元素的逐一对应复制。
深层复制
当被复制的对象数据成员是指针范例时，不是复制该指针成员自己，而是将指针所指对象举行复制
例6-21 对象的浅层复制
#include
#include
using namespace std;
class Point {
//类的声明同例6-16
//……
};
class ArrayOfPoints {
//类的声明同例6-18
//……
};
int main() {
int count;
cout << "lease enter the count of points: ";
cin >> count;
ArrayOfPoints pointsArray1(count); //创建对象数组
pointsArray1.element(0).move(5,10);
pointsArray1.element(1).move(15,20);
ArrayOfPoints pointsArray2(pointsArray1); //创建副本
cout << “Copy of pointsArray1:” << endl;
cout << "oint_0 of array2: " << pointsArray2.element(0).getX() << ", "
<< pointsArray2.element(0).getY() << endl;
cout << "oint_1 of array2: " << pointsArray2.element(1).getX() << ", "
<< pointsArray2.element(1).getY() << endl;
pointsArray1.element(0).move(25, 30);
pointsArray1.element(1).move(35, 40);
cout<<“After the moving of pointsArray1:”<<endl;
cout << "oint_0 of array2: " << pointsArray2.element(0).getX() << ", "
<< pointsArray2.element(0).getY() << endl;
cout << "oint_1 of array2: " << pointsArray2.element(1).getX() << ", "
<< pointsArray2.element(1).getY() << endl;
return 0;
}
运行结果如下：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Copy of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
After the moving of pointsArray1:
Point_0 of array2: 25, 30
Point_1 of array2: 35, 40
Deleting…
Destructor called.
Destructor called.
Deleting…
接下来步调出现运行错误。

例6-22 对象的深层复制
#include
#include
using namespace std;
class Point { //类的声明同例6-16
};
class ArrayOfPoints {
public:
ArrayOfPoints(const ArrayOfPoints& pointsArray);
//其他成员同例6-18
};
ArrayOfPoints::ArrayOfPoints(const ArrayOfPoints& v) {
size = v.size;
points = new Point[size];
for (int i = 0; i < size; i++)
points = v.points;
}
int main() {
//同例6-20
}
步调的运行结果如下：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Default Constructor called.
Default Constructor called.
Copy of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
After the moving of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
Deleting…
Destructor called.
Destructor called.
Deleting…
Destructor called.
Destructor called.

1. #include <iostream>
2. #include <cassert>
3. using namespace std;
5. class Point {
6. public:
7.     Point() : x(0), y(0) {
8.         cout << "Default Constructor called." << endl;
9.     }
10.     ~Point() {
11.         cout << "Destructor called." << endl;
12.     }
13.     void move(int newX, int newY) { x = newX; y = newY; }
14.     int getX() const { return x; }
15.     int getY() const { return y; }
16. private:
17.     int x, y;
18. };
20. class ArrayOfPoints {
21. public:
22.     ArrayOfPoints(int size) : size(size) {
23.         points = new Point[size];
24.     }
25.    
26.     // 复制构造函数（深层复制）
27.     ArrayOfPoints(const ArrayOfPoints& v) {
28.         size = v.size;
29.         points = new Point[size];
30.         for (int i = 0; i < size; i++)
31.             points[i] = v.points[i];
32.     }
33.    
34.     ~ArrayOfPoints() {
35.         cout << "Deleting..." << endl;
36.         delete[] points;
37.     }
38.    
39.     Point& element(int index) {
40.         assert(index >= 0 && index < size);
41.         return points[index];
42.     }
43.    
44. private:
45.     Point* points;
46.     int size;
47. };
49. int main() {
50.     int count;
51.     cout << "Please enter the number of points:" << endl;
52.     cin >> count;
53.    
54.     ArrayOfPoints pointsArray1(count); //创建对象数组
55.     pointsArray1.element(0).move(5, 10);
56.     pointsArray1.element(1).move(15, 20);
57.    
58.     ArrayOfPoints pointsArray2(pointsArray1); //创建副本（深层复制）
59.    
60.     cout << "Copy of pointsArray1:" << endl;
61.     cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
62.          << pointsArray2.element(0).getY() << endl;
63.     cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
64.          << pointsArray2.element(1).getY() << endl;
65.    
66.     pointsArray1.element(0).move(25, 30);
67.     pointsArray1.element(1).move(35, 40);
68.    
69.     cout << "After the moving of pointsArray1:" << endl;
70.     cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
71.          << pointsArray2.element(0).getY() << endl;
72.     cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
73.          << pointsArray2.element(1).getY() << endl;
74.    
75.     return 0;
76. }

复制代码

6、动态数组——根本模板类

本标题有后缀
标题形貌：
动态数组，是相对于静态数组而言。静态数组的长度是编程时步调员预先界说好的，在整个步调运行中，数组巨细无法改变。
而动态数组则否则，它可以随步调运行的须要而在运行时重新指定巨细。
动态数组的内存空间是从堆（heap）上分配（即动态分配）的。是通过实验new（或malloc等函数）使用，而为其分配存储空间。当步调实验到这些语句时，才为其分配。
对于动态数组类所申请的内存，在使用完必须由步调员自己开释，否则严峻会引起内存走漏。
以是内存的申请肯定要有借有还，才气再借不难，也要注意，不能多还。
已知动态数组模板类的界说如下。
请增补完备
1、构造函数
2、析构函数
3、返回空间巨细的 capacity()  函数
4、operator[] 重载
template
class DynamicArray {
private:
T* array; //pointer  ，一个T范例的指针
unsigned int mallocSize; //分配空间的巨细。
public:
//Constructors
// cout<<endl<< “new T[”<mallocSize<<“] malloc “<< this->mallocSize << “*”<<sizeof(T)<<”=”<mallocSize *sizeof(T)<<" bytes memory in heap";
DynamicArray(unsigned length, const T &content) ; // mallocSize=length; 设置每个元素的初始内容是 content；
// Destructors
// cout<<endl<< “delete[] array free “<< this->mallocSize << “*”<<sizeof(T)<<”=”<mallocSize *sizeof(T)<<" bytes memory in heap";
~DynamicArray();
//return the this->mallocSize
unsigned int capacity() const;
// for the array=someT.
T& operator[](unsigned int i) ;
};
输入一个整数
输出请分析拜见下面的用例和步调后缀。
样例输入：
3
样例输出
new T[3] malloc 34=12 bytes memory in heap
new T[3] malloc 38=24 bytes memory in heap
capacity:3
-1 -1 -1
-2.1 -2.1 -2.1
0 1 2
0 1.1 2.2
delete[] array free 38=24 bytes memory in heap
delete[] array free 34=12 bytes memory in heap

1. #include <iostream>
2. using namespace std;
4. template <typename T>
5. class DynamicArray {
6. private:
7.     T* array; //pointer  ，一个T类型的指针
8.     unsigned int mallocSize; //分配空间的大小。
10. public:
11.     //Constructors
12.     // cout<<endl<< "new T["<<this->mallocSize<<"] malloc "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
13.     DynamicArray(unsigned length, const T &content) {
14.         mallocSize = length;
15.         array = new T[length];
16.         for (unsigned int i = 0; i < length; ++i) {
17.             array[i] = content;
18.         }
19.         cout << "new T[" << mallocSize << "] malloc " << mallocSize << "*" << sizeof(T) << "=" << mallocSize * sizeof(T) << " bytes memory in heap\n";
20.     }
22.     // Destructors
23.     // cout<<endl<< "delete[] array free "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
24.     ~DynamicArray() {
25.         cout << endl << "delete[] array free " << mallocSize << "*" << sizeof(T) << "=" << mallocSize * sizeof(T) << " bytes memory in heap";
26.         delete[] array;
27.     }
29.     //return the this->mallocSize
30.     unsigned int capacity() const {
31.         return mallocSize;
32.     }
34.     // for the array[i]=someT.
35.     T& operator[](unsigned int i) {
36.         return array[i];
37.     }
38. };

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告