标签：p2 p1 管理 int 动态内存 new ptr 指针

指针常与堆（heap）空间有关。在堆这个内存区域中，允许程序在运行时以指针形式申请一部分存储单元（比较：其他的存储空间都是在编译时完成）。

char* S = (char*)malloc(1); 
free(s);
int*p= (int*) malloc(4*10);
free(p);

new  <类型名> (初值) ;     //申请一个变量的空间
new  <类型名>[常量表达式] ;   //申请数组

delete   <指针名>;    //删除一个变量/对象
delete []  <指针名>;     //删除数组空间

char*s = new char(a);
delete s;
int* p= new int[10];
delete []p;

举个c语言中动态内存管理的例子：

#include <stdlib.h>
#include <stdio.h>
int main()
{
    int *p;
    p = (int *)malloc(sizeof(int));//malloc 申请的空间默认类型为(void *)
    *p = 23;
    printf("%d\n", *p);
    free(p);
    system("pause");
    return 0;
}

比较于 c语言中的malloc和free ，c++中的new和delete 有四个优势。

1. new能自动计算要分配的内存大小，不必用sizeof计算所要分配的内存字节数；
2. new不需要进行类型转换，能够自动返回正确的指针类型；
3. new可以对分配的内存进行初始化；
4. new和delete可以被重载。

那么接下再来举个c++中的例子：

#include <iostream>
int main()
{
    int *p = nullptr;
    int *q{nullptr}; // C++11 Initializer List
    p = new int(42);
    q = new int[4];
    std::cout << "Before: *p =" << *p << std::endl;
    *p = 24;
    std::cout << "After: *p =" << *p << std::endl;
    for (int i = 0; i < 4; i++)
    {
        *(q + i) = 10 + i;
        std::cout << *(q + i) << std::endl;
    }
    delete p;
    delete[] q;
    std::cin.get();
    return 0;
}

补充：智能指针

由于一般的程序员都很懒，经常忘记使用delete或free来释放动态内存，造成内存泄漏。所以c++提供了智能指针，会自动释放所指向的对象。

注意：智能指针不允许先定义，在为它分配内存空间

x_ptr<type> p1, p2(new type); //正确
p1 = new type;                //错误
p1 = p2;                      //此语句在 auto_ptr 或 share_ptr 中是正确的，但是在 unique_ptr中是错的

1. auto_ptr

auto_ptr 是 c++98 标准定义的独占智能指针，即一个对象只能被一个auto_ptr 所指向，两个同类型的auto_ptr 指针不能指向同一个对象，指针的复制或赋值操作都会改变对象的所有权，被复制的auto_ptr指针不在指向任何一个元素。

#include <iostream>
#include <memory>
#include <string>
using namespace std;
int main()
{
    auto_ptr<string> p1(new string("There is only noe point to me."));
    auto_ptr<string> p2;
    p2 = p1;             //p1不在指向任何对象，其所指向对象由p2指向； 会引发运行时错误
    cout << *p1;         //发生运行错误，因为p1没有指向任何对象；
    cout << *p2 << endl; //输出There is only noe point to me.
    //p1=new string("dd"); 不能用这种方式给只能指针赋值
    auto_ptr<string> p3(p2); //p2不在指向任何对象，其所指向对象由p3指向；
    cout << *p3 << endl;     //输出There is only noe point to me.
    system("pause");
    return 0;
}

2. unique_ptr

c++11标准采用了更安全的智能指针unique_ptr ，其用途和auto_ptr 类似，只是禁止了指针之间的赋值，也不允许用一个指针初始化另一个指针，若发现这两种情况，在编译时就会发生错误。

unique_ptr<string> p1(new string("There is only noe point to me."));
unique_ptr<string> p2;
unique_ptr<string> p3(p1); //错误
p2 = p1;                   //错误

3. share_ptr

这是一种共享指针，即多个指针可以指向同一个对象。在痛类型的 share_ptr 指针之间进行相互赋值，或用一个share_ptr 指针去初始化正在定义的指针，都不会有错误。它还采用引用计数，关联了一个计数器，其中保存着指向同一个对象的指针（包括费智能指针）数。对指针进行复制是计数器会增1.如进行指针之间的赋值，用一个指针初始化另一个指针，向函数中传递指针参数都会使计数器增加。反之，当一个指针离开所指对象时，就会减少该对象的引用次数，当计数器为0时，就会销毁该对象。

#include <iostream>
#include <memory>
using namespace std;
void swap(shared_ptr<int> a, shared_ptr<int> b)
{
    int t;
    t = *a;
    *a = *b;
    *b = t;
}
int main()
{
    shared_ptr<int> p1(new int(9));
    shared_ptr<int> p2(p1);
    shared_ptr<int> p3(new (int)), p4(new int(8)), p5;
    cout << "p1=" << *p1 << "\tp4=" << *p4 << endl;
    swap(p1, p4);
    cout << "p1=" << *p1 << "\tp4=" << *p4 << endl;
    p3 = p4 = p5 = p1;
    system("pause");
    return 0;
}

标签：p2,p1,管理,int,动态内存,new,ptr,指针
来源： https://www.cnblogs.com/stu-jyj3621/p/12896343.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。