c++——new和delete

new和delete表示从堆区申请空间和释放空间

与malloc,calloc,realloc相比较

1.malloc返回一个void指针,c++不允许将void赋值给其他任何指针,必须强转。
2.malloc可能申请内存失败,所以必须判断返回值来确保内存分配成功。
3.malloc 不会调用构造函数。free 不会调用析构函数

new delete

1、给基本类型申请空间
void test0()
{
    //基本类型
    int *p = NULL;
    
    p = new int;
    *p = 100;
    cout<<"*p = "<<*p<<endl;//100

    delete p;
}
2、申请基本类型数组空间
void test1()
{
    int *arr = NULL;
    arr = new int[5]{1,2,3,4,5};
    
    int i=0;
    for(i=0;i<5;i++)
    {
        cout << arr[i] << " ";
    }
    cout  << endl;
}
void test2()
{
    char *p = NULL;
    p = new char[32];
    strcpy(p,"hehehe");
    cout << p <<endl;
    delete [] p;
}
注意

new 没有加[] delete释放的时候 就不加[]
new 加[] delete释放的时候 就加[]

3、给类对象申请空间
void test4()
{
    Person *p = new Person("lucy",18);
    p->display();
    delete p;
}

对象数组

本质是数组,数组元素是类的对象

如果想让对象数组中的元素调用有参构造 必须人为使用 有参构造初始化。
void test5()
{
    Person arr1[5] = {Person("lucy",18),Person("bob",19),Person("tom",20)};
    arr1[0].display();
    arr1[1].display();
    arr1[2].display();
}
用new delete申请 对象数组
void test08()
{
    //第一种方式
    Person *arr = NULL;
    arr = new Person[5];//调用无参构造

    delete [] arr;

    //第二种方式:
    //初始化的元素 调用有参构造 没有初始化 的调用无参构造
    Person *arr2 = new Person[5]{Person("lucy",18), Person("bob",20)};
    (*(arr2+0)).showPerson();
    arr2[0].showPerson();
    (arr2+1)->showPerson();
    delete [] arr2;
}
尽量不要用delete释放void *
malloc、free和new、delete 不可以混搭使用
桥接模式是一种结构型设计模式,它将抽象实现分离,使它们可以独立地变化。桥接模式的核心思想是将一个大类或一组类分解成抽象实现两个独立的维度,使它们可以独立地变化扩展,同时通过桥接来将它们连接起来。 在C++中,桥接模式通常通过虚函数实现。抽象部分通过基类定义接口,而实现部分通过派生类实现具体的功能。通过将抽象部分的指针作为参数传递给实现部分的函数,就可以实现两个部分的连接。 下面是一个简单的桥接模式的C++示例: ```c++ class Implementor { public: virtual void operation() = 0; virtual ~Implementor() {} }; class ConcreteImplementorA : public Implementor { public: void operation() override { // 具体的实现A } }; class ConcreteImplementorB : public Implementor { public: void operation() override { // 具体的实现B } }; class Abstraction { public: Abstraction(Implementor* implementor) : m_implementor(implementor) {} virtual void operation() = 0; virtual ~Abstraction() {} protected: Implementor* m_implementor; }; class RefinedAbstraction : public Abstraction { public: RefinedAbstraction(Implementor* implementor) : Abstraction(implementor) {} void operation() override { m_implementor->operation(); // 其他操作 } }; int main() { Implementor* implementorA = new ConcreteImplementorA(); Implementor* implementorB = new ConcreteImplementorB(); Abstraction* abstractionA = new RefinedAbstraction(implementorA); Abstraction* abstractionB = new RefinedAbstraction(implementorB); abstractionA->operation(); abstractionB->operation(); delete abstractionA; delete abstractionB; delete implementorA; delete implementorB; return 0; } ``` 在上面的示例中,Implementor是实现部分的抽象基类,ConcreteImplementorAConcreteImplementorB是具体的实现类。Abstraction是抽象部分的基类,RefinedAbstraction是抽象部分的具体实现类。在main函数中,我们创建了不同的ImplementorAbstraction对象,并通过它们来完成不同的操作。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值