c++笔记(8) 指针及动态内存管理
指针：指针变量，可以用用来引用数组，对象，任何变量的地址。指针中保存的是地址，用*(解引运算符)来访问内存中的数据
指针的使用：
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
using namespace std;
int main(int argc, char *argv[])
{
int count = 5;
int* p;
p = &count;
cout << "The vauel of count is " << *p << endl;
cout << "The address of count is " << p << endl;
return 0;
}
与局部变量一样，如果不为局部指针赋值，其内容是任意的，可以将一个指针值赋值为0，这是一个特殊的指针值，表示指针未指向任何变量。因此，应该始终对指针保持初始化。以避免错误。
2.用typedef定义同义类型
typedef int* intPointer
typedef并不是创造新的数据类型，而是给已有的数据类型起一个别名
3.常量指针
常量指针指向一个不变的内存位置，但是内存中的数据是可以改变的
double radius = 5;
double* const p = &radius; //常量指针
const double *p = &radius; // 指针指向的数据(radius)是常量
const double* const p = &radius; // 指向常量的常量指针
4. 数组和指针
在c++中，数组名实际上是指向数组第一个元素的常量指针，数组与指针关系密切。
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
using namespace std;
int main(int argc, char *argv[])
{
int list[6] = {1,2,3,4,5,6};
int* p = list;
for(int i=0; i<6; i++)
{
cout << "Adress: " << (p+i) << " value: " << *(p+i) << " value: " << p[i] << endl;
}
return 0;
}
5. 函数调用时传递指针参数
函数的参数可以是指针，指针参数可以通过值传递或者引用传递的方式进行传递
例如下面的swap()函数
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
using namespace std;
void swap1(int a, int b)
{
int tmp = a;
a = b;
b = tmp;
}
void swap2(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}
void swap3(int* pa, int* pb)
{
int tmp = *pa;
*pa = *pb;
*pb = tmp;
}
void swap4(int* &a, int* &b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
int main(int argc, char *argv[])
{
int a = 1;
int b = 2;
swap1(a,b);
cout << "After swap a is " << a << " and b is " << b << endl;
a = 1;
b = 2;
swap2(a, b);
cout << "After swap a is " << a << " and b is " << b << endl;
a = 1;
b = 2;
int* p1 = &a;
int* p2 = &b;
swap3(p1, p2);
cout << "After swap a is " << a << " and b is " << b << endl;
a = 1;
b = 2;
p1 = &a;
p2 = &b;
swap4(p1, p2);
cout << "After swap a is " << a << " and b is " << b << endl;
return 0;
}
运行结果：
swap1()未实现交换
函数传引用， 形参相当于实参的一个别名
6. 从函数中返回指针
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
using namespace std;
int* reverse(int*, int);
void printArray(int*, int);
int main(int argc, char *argv[])
{
int size = 5; // 数组名不能动态定义
int a[5] = {1,2,3,4,5};
int* p = reverse(a, size);
printArray(p, size);
return 0;
}
int* reverse(int* list, int SIZE)
{
for(int i=0, j=SIZE-1; i<j; i++, j--)
{
int tmp = list[i];
list[i] = list[j];
list[j] = tmp;
}
return list;
}
void printArray(int* list, int SIZE)
{
for(int i=0; i<SIZE; i++)
{
cout << list[i];
}
cout << endl;
}
函数reverse()返回一个指针p。传入的第一个参数是实参(数组)的地址，实际上返回的也是同一个地址。
7，有用的数组函数
min_element
max_element
sort
random_shuffle
find：find函查找相应的元素，如果找到，返回的是数组元素对应的指针，如果没有找到，返回数组最后一个元素的后一个位置的指针，这就是为什么这些函数的参数为(list, list +size), 多出的一个指针应该就是分配给未找到元素时的这种情况。
这些对数组进行操作的函数都在头文件algotithm中，这些函数的参数都是指针，返回的都是相应元素的指针。
例子：
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
#include <algorithm>
using namespace std;
void printArray(int*, int);
int main(int argc, char *argv[])
{
int size = 6;
int list[] = {4, 2, 3, 6, 5, 1};
printArray(list, size);
int* min = min_element(list, list+6); // 参数是指针
int* max = max_element(list, list+6); // 参数
cout << "The minum is of list is " << *min << " at index " << (min - list) << endl; //注意这里的指针相减
cout << "The maxum is of list is " << *max << " at index " << (max - list) << endl; //注意这里的指针相减
random_shuffle(list, list+6);
printArray(list, size);
sort(list, list+6);
printArray(list, 6);
// find
int key = 4; // 要查找的元素
int* p = find(list, list+6, key);
if(p!=(list+6)) // 没找到要查找的元素
{
cout << "The value " << *p << "is found at index " << (p-list) << endl;
}
else
{
cout << "The value " << *p << "is not found" << endl;
}
return 0;
}
void printArray(int* list, int SIZE)
{
for(int i=0; i<SIZE; i++)
{
cout << setw(3) << list[i];
}
cout << endl;
}p != list+6， 证明找到了相应的元素
8，动态持久内存分配：
new操作符可以在运行时为基本数据类型，数组和对象分配持久的内存空间。
int *p = new int(4); //为一个整形变量动态分配内存空间, 将地址赋值给指针p
cin >> size;
int *list = new int[size]; //动态数组， 数组大小在程序运行时输入 动态数组， 数组大小在程序运行时输入，而创建一个普通数组时，数组的大小在程序编译时就已经定下来了
使用new操作符分配的内存是持久存在的，直到它被显式的释放或者程序退出。
delete p; //数
delete []p; // 数组
例子：重新实现数组reverse()
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
#include <algorithm>
using namespace std;
void printArray(int*, int);
int* reverse(int*, int);
int main(int argc, char *argv[])
{
int SIZE = 10;
int* p = new int[SIZE];
for(int i=0; i<SIZE; i++)
{
p[i] = i* 3 + 3;
}
printArray(p, SIZE);
int* p1 = reverse(p, SIZE);
printArray(p, SIZE);
printArray(p1, SIZE);
return 0;
}
int* reverse(int* list, int size)
{
int* result = new int[size];
for(int i=0,j=size-1; i<size; i++,j--)
{
result[i] = list[j];
}
return result;
}
void printArray(int* list, int SIZE)
{
for(int i=0; i<SIZE; i++)
{
cout << setw(3) << list[i];
}
cout << endl;
}
C++中，局部变量的内存空间是在栈中分配的，而由new操作符分配的内存空间则出自称为“自由存储区域”或者“堆”的存储区域。
分配的空间一直是可用的，直至释放。
内存泄漏：
如下的代码：
int* p = new int;
*p = 45;
p = new int;第一句： 将一个动态内存赋值给指针p;
第二局：给变量赋值45；
第三局： 重新给p赋值一个新的地址值
这样会导致保存p指向的内存空间改变，存储45的内存将无法再访问，而这段内存也无法释放，这就是内存泄漏。
9. 创建及访问动态对象：
调用对象的构造函数可以动态的创建对象，new className(arguments)，对象的地址会被赋值给相应的指针,调用对象时任然用解引运算符*
例如：
int main(int argc, char *argv[])
{
string* p1 = new string(); // 无参构造函数
string* p2 = new string("hello world"); // 有参数的构造函数
// 动态对象的调用
(*p2).substr(0,3);
(*p1).append(" C++");
cout << (*p1) << endl;
cout << (*p2) << endl;
delete p1;
delete p2;
return 0;
}end
this指针：指向被调用的对象本身。
this指针是为了解决这里碰到的问题：https://blog.csdn.net/zj1131190425/article/details/82888131
即类中成员方法的参数名如果与数据域的变量名相同，就会出现覆盖的问题
例如之前的circle类： 成员函数的参数名不能命名为radius,因为radius是数据域
利用this指针就可以实现
circle类实现如下：
Circle::Circle(double radius)
{
this->radius = radius;
number_of_obj++; // ++
}
void Circle::setRadius(double radius)
{
this->radius = radius;
}9. 析构函数
每一个类都有一个析构函数，当对象销毁时将自动调用该函数，析构函数与构造函数是相对的概念，如果类中没有定义析构函数，编译器将自动定义一个缺省的析构函数，析构函数与构造函数一样，与类名相同，但前面加上~符号
作用： 回忆之前的Circle类， 其中数据域有一个static类型的变量。用来记录创建的对象的个数，每当创建一个对象，numberOfObject加一。 如果采用new运算符创建动态对象， 在对象调用完毕时，会使用delete删除指向对象的指针，这时对象会被销毁，就需要执行一个析构函数，实现numberOfObject减一。
Circle::~Circle() // 析构函数，在对象销毁时调用
{
number_of_obj--;
}Course类的实现：
实现一个课程类，用于选课学生数据的保存：
数据域包括：
课程名 courseName
选课容量 capacity
选课人数 student_number
学生名单 students
类成员方法：
add_student() // 添加学生
drop_student() // 删除学生
get_student_list()
get_courseName()
get_student_number()
同时会用到构造函数和析构函数：
code:
course.h
// course类的定义
#ifndef COURSE_H
#define COURSE_H
#include <string>
using namespace std;
class Course
{
private: // 数据域
int courseCapacity; // 课程容量
int student_number; // 记录选课学生人数
string courseName; // 课程名称
string* students; // 存储学生的数组， string【capacity】
public: // 成员方法
Course(const string& courseName, int courseCapacity); // constructor
~Course(); // 析构函数
string getCourseName() const; // 只读函数
void addStudent(const string& name);
void dropStudent(const string& name);
string* getStudents() const; // 返回学生的名单
int getNumberOfStudent() const;
};
#endif
course.cpp course类的实现
// 类的实现
#include "E:\back_up\code\c_plus_code\chapter8\external_file\course.h"
#include <string>
#include <iostream>
using namespace std;
Course::Course(const string& courseName, int courseCapacity)
{
this->courseName = courseName;
this->courseCapacity = courseCapacity;
students = new string[courseCapacity];
student_number = 0;
}
Course::~Course()
{
delete []students; // 删除students指针
}
string Course::getCourseName() const
{
return courseName;
}
void Course::addStudent(const string& name)
{
if(student_number >= courseCapacity)
{
cout << "you cat not add student because the course is full." << endl;
}
else
{
students[student_number++] = name;
}
}
void Course::dropStudent(const string& name)
{
bool found_flag = false;
int index = 0;
for(int i=0; i<student_number-1; i++)
{
if(name==students[i])
{
found_flag = true;
index = i;
break;
}
}
if(found_flag)
{
for(int i=index; i<student_number-2; i++)
{
students[i] = students[i+1];
}
student_number--;
cout << "Student " << name << " is successfully deleted from " << courseName << endl;
}
else // 如果学生不在名单中
{
cout << "Student " << name << " is not in the course " << courseName << endl;
}
}
string* Course::getStudents() const
{
return students;
}
int Course::getNumberOfStudent() const
{
return student_number;
}
main.cpp
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
#include <algorithm>
#include "E:\back_up\code\c_plus_code\chapter8\external_file\course.h"
using namespace std;
void printStudentList(string*, int);
int main(int argc, char *argv[])
{
Course course1("Mathg", 3);
//Course course2("Data Analyse", 4);
cout << "course1's name is " << course1.getCourseName() << " and now it has " << course1.getNumberOfStudent() << " students" << endl;
course1.addStudent("Tonny");
course1.addStudent("Andrea");
cout << "course1's name is " << course1.getCourseName() << " and now it has " << course1.getNumberOfStudent() << " students" << endl;
cout << "The student list: " << endl;
printStudentList(course1.getStudents(), course1.getNumberOfStudent());
course1.addStudent("wang hau");
cout << "course1's name is " << course1.getCourseName() << " and now it has " << course1.getNumberOfStudent() << " students" << endl;
cout << "The student list: " << endl;
printStudentList(course1.getStudents(), course1.getNumberOfStudent());
course1.addStudent("huhuhu"); // 课程已满
course1.dropStudent("zhangjun"); // 删除不存在的学生
course1.dropStudent("Andrea");
cout << "course1's name is " << course1.getCourseName() << " and now it has " << course1.getNumberOfStudent() << " students" << endl;
cout << "The student list: " << endl;
printStudentList(course1.getStudents(), course1.getNumberOfStudent());
//Course course2("DataScience", 50);
return 0;
}
void printStudentList(string* student_list, int num)
{
for(int i=0; i<num; i++)
{
cout << student_list[i] << endl;
}
cout << endl;
}
运行结果：
拷贝构造函数：每一个类都有一个都有一个拷贝构造函数，用于拷贝对象。拷贝构造函数可以用来创建一个对象，并用另一个对象的数据初始化新建对象。每个类都会有一个缺省的拷贝构造函数
Circle(const Circle&)
拷贝构造函数和按成员赋值运算符（=）是对对象赋值采用的一种浅拷贝。
自定义拷贝构造函数，实现深拷贝：
Course类中：
代码：
course.h
// course类的定义
#ifndef COURSE_H
#define COURSE_H
#include <string>
using namespace std;
class Course
{
private: // 数据域
int courseCapacity; // 课程容量
int student_number; // 记录选课学生人数
string courseName; // 课程名称
string* students; // 存储学生的数组， string【capacity】
public: // 成员方法
Course(const string& courseName, int courseCapacity); // constructor
~Course(); // 析构函数
Course(const Course& course); // 拷贝构造函数
string getCourseName() const; // 只读函数
void addStudent(const string& name);
void dropStudent(const string& name);
string* getStudents() const; // 返回学生的名单
int getNumberOfStudent() const;
};
#endif
course.cpp:
// 类的实现
#include "E:\back_up\code\c_plus_code\chapter8\external_file\course.h"
#include <string>
#include <iostream>
using namespace std;
Course::Course(const string& courseName, int courseCapacity)
{
this->courseName = courseName;
this->courseCapacity = courseCapacity;
students = new string[courseCapacity];
student_number = 0;
}
Course::~Course()
{
delete []students; // 删除students指针
}
Course::Course(const Course& course) // 拷贝构造函数，自定义实现，深拷贝
{
courseName = course.courseName;
courseCapacity = course.courseCapacity; // deep copy
student_number = course.student_number;
students = new string[courseCapacity];
// deepcopy实现两个copy的对象数据域指针students应该相互独立，
//如果用浅拷贝(默认的拷贝构造函数或者“=”浅拷贝。
//两个指针是指向相同的地址，这样在调用析构函数是，
//同一个指针会delete两次，导致程序报错
for(int i=0; i<student_number; i++)
{
students[i] = course.students[i];
}
}
string Course::getCourseName() const
{
return courseName;
}
void Course::addStudent(const string& name)
{
if(student_number >= courseCapacity)
{
cout << "you cat not add student because the course is full." << endl;
}
else
{
students[student_number++] = name;
}
}
void Course::dropStudent(const string& name)
{
bool found_flag = false;
int index = 0;
for(int i=0; i<student_number-1; i++)
{
if(name==students[i])
{
found_flag = true;
index = i;
break;
}
}
if(found_flag)
{
for(int i=index; i<student_number-2; i++)
{
students[i] = students[i+1];
}
student_number--;
cout << "Student " << name << " is successfully deleted from " << courseName << endl;
}
else // 如果学生不在名单中
{
cout << "Student " << name << " is not in the course " << courseName << endl;
}
}
string* Course::getStudents() const
{
return students;
}
int Course::getNumberOfStudent() const
{
return student_number;
}
main.cpp
#include <iostream>
#include <string>
#include <iomanip>
#include <sstream> // 将数字转化为字符串
#include <algorithm>
#include "E:\back_up\code\c_plus_code\chapter8\external_file\course.h"
using namespace std;
void printStudentList(string*, int);
int main(int argc, char *argv[])
{
Course course1("Mathg", 3);
//Course course2("Data Analyse", 4);
cout << "course1's name is " << course1.getCourseName() << " and now it has " << course1.getNumberOfStudent() << " students" << endl;
course1.addStudent("Tonny");
course1.addStudent("Andrea");
cout << "course1's name is " << course1.getCourseName() << " and now it has " << course1.getNumberOfStudent() << " students" << endl;
cout << "The student list: " << endl;
printStudentList(course1.getStudents(), course1.getNumberOfStudent());
course1.addStudent("wang hau");
cout << "course1 infomation: " << endl;
cout << "course1's name is " << course1.getCourseName() << " and now it has " << course1.getNumberOfStudent() << " students" << endl;
cout << "The student list: " << endl;
printStudentList(course1.getStudents(), course1.getNumberOfStudent());
cout << "course2 infomation: " << endl;
Course course2(course1); // course2 copy course1
cout << "course2's name is " << course2.getCourseName() << " and now it has " << course2.getNumberOfStudent() << " students" << endl;
cout << "The student list: " << endl;
printStudentList(course2.getStudents(), course2.getNumberOfStudent());
return 0;
}
void printStudentList(string* student_list, int num)
{
for(int i=0; i<num; i++)
{
cout << student_list[i] << endl;
}
cout << endl;
}
运行结果：实现了对象的copy
为什么Course类中，要自定义拷贝构造函数，实现深拷贝？
原因：：因为course类数据域有指向数组的指针students,如果使用上述的浅拷贝，在copy过程中，两个指针拷贝时，保存了相同地址，即指向了相同的地址。但是在程序执行完毕时，对象需要调用析构函数delete指针students，但是如果两个对象是copy的关系，则会调用两次析构函数删除相同的指针，这是程序就会报错。所以需要自定义拷贝构造函数，实现深拷贝。使两个对象中的数据域中指针students相互独立，就不会出现上述情况。
