c++的delete
时间: 2024-03-19 22:38:14 浏览: 36
在C++中,`delete`是用于释放动态分配的内存的关键字。当我们使用`new`运算符在堆上创建对象或数组时,需要使用`delete`来手动释放这些内存,以防止内存泄漏。
`delete`有两种形式:`delete`和`delete[]`。它们分别用于释放单个对象和释放数组。
当我们使用`new`创建单个对象时,可以使用`delete`来释放该对象的内存。例如:
```cpp
int* ptr = new int; // 创建一个int类型的对象
// 使用ptr指针操作对象
delete ptr; // 释放ptr指向的内存
```
当我们使用`new`创建数组时,应该使用`delete[]`来释放数组的内存。例如:
```cpp
int* arr = new int[5]; // 创建一个包含5个int类型元素的数组
// 使用arr指针操作数组
delete[] arr; // 释放arr指向的数组内存
```
需要注意的是,使用`delete`或`delete[]`释放内存后,指针将成为悬空指针(dangling pointer),即指向已释放的内存。为了避免悬空指针的问题,可以将指针设置为`nullptr`,以确保不会再被误用。
相关问题
c++类模版
C++类模板是一种通用的类定义,可以用于创建具有相同结构但可以使用不同数据类型的类。C++类模板是使用模板参数定义的,该参数可以用于定义函数、类等。模板参数可以是类型、值或模板本身。
下面是一个简单的C++类模板示例,它定义了一个用于存储任何数据类型的堆栈类:
```
template <class T>
class Stack {
private:
T *stackArray; // 指向堆栈的指针
int stackSize; // 堆栈的大小
int top; // 栈顶元素的位置
public:
Stack(int size) {
stackSize = size;
stackArray = new T[size];
top = -1;
}
~Stack() {
delete[] stackArray;
}
void push(T value) {
if (top == stackSize - 1) {
throw "Stack is full!";
}
top++;
stackArray[top] = value;
}
T pop() {
if (top == -1) {
throw "Stack is empty!";
}
T value = stackArray[top];
top--;
return value;
}
};
```
在这个例子中,我们使用了类模板参数 `T`,这个参数可以用于定义 `stackArray` 数组的数据类型。我们还使用了 `new` 运算符来在堆上分配内存,并使用 `delete` 运算符来释放分配的内存。最后,我们定义了两个成员函数 `push()` 和 `pop()` 来向栈中添加和删除元素。
使用这个类模板非常简单,只需在定义堆栈对象时指定数据类型即可,例如:
```
Stack<int> intStack(10); // 创建一个可以存储整数的堆栈
Stack<double> doubleStack(5); // 创建一个可以存储双精度浮点数的堆栈
```
c++多态代码实现
C++中多态的实现方式主要有以下几种:
1. 虚函数(Virtual Functions):通过在基类中声明虚函数,并在派生类中进行重写,实现多态性。当通过基类指针或引用调用虚函数时,会根据实际对象的类型来确定调用哪个函数。
示例代码如下:
```cpp
class Animal {
public:
virtual void sound() {
cout << "Animal makes a sound." << endl;
}
};
class Dog : public Animal {
public:
void sound() {
cout << "Dog barks." << endl;
}
};
class Cat : public Animal {
public:
void sound() {
cout << "Cat meows." << endl;
}
};
int main() {
Animal* animal1 = new Dog();
Animal* animal2 = new Cat();
animal1->sound(); // 输出:Dog barks.
animal2->sound(); // 输出:Cat meows.
delete animal1;
delete animal2;
return 0;
}
```
2. 纯虚函数(Pure Virtual Functions):在基类中声明纯虚函数,派生类必须实现该函数。纯虚函数使得基类成为抽象类,无法实例化,只能作为接口使用。
示例代码如下:
```cpp
class Shape {
public:
virtual void draw() = 0; // 纯虚函数
};
class Circle : public Shape {
public:
void draw() {
cout << "Drawing a circle." << endl;
}
};
class Rectangle : public Shape {
public:
void draw() {
cout << "Drawing a rectangle." << endl;
}
};
int main() {
Shape* shape1 = new Circle();
Shape* shape2 = new Rectangle();
shape1->draw(); // 输出:Drawing a circle.
shape2->draw(); // 输出:Drawing a rectangle.
delete shape1;
delete shape2;
return 0;
}
```
3. 虚析构函数(Virtual Destructors):当基类指针指向派生类对象时,如果基类的析构函数不是虚函数,那么只会调用基类的析构函数,而不会调用派生类的析构函数。为了正确释放派生类对象的资源,需要将基类的析构函数声明为虚函数。
示例代码如下:
```cpp
class Base {
public:
virtual ~Base() {
cout << "Base destructor." << endl;
}
};
class Derived : public Base {
public:
~Derived() {
cout << "Derived destructor." << endl;
}
};
int main() {
Base* base = new Derived();
delete base; // 输出:Derived destructor. Base destructor.
return 0;
}
```