C++ Primer 学习笔记 第十二章 动态内存与智能指针

最新推荐文章于 2022-12-23 17:18:50 发布
最新推荐文章于 2022-12-23 17:18:50 发布
阅读量758 收藏
点赞数 1
文章标签： c++ c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HELLOWORLD2424/article/details/122690080
版权

402 创建智能指针

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
using namespace std;

int main() {
    shared_ptr<string> p1;
    shared_ptr<list<int>> p2;
    if (p1->empty())
        *p1 = "hi";

    shared_ptr<int> p3 = make_shared<int>(42);
    shared_ptr<string> p4 = make_shared<string>(10, '9');
    shared_ptr<int> p5 = make_shared<int>();
    auto p6 = make_shared<vector<string>>();

    auto p = make_shared<int>(42);
    auto q(p);

    auto r = make_shared<int>(42);
    r = q;
    
    return 0;
}

402 智能指针例子

int main() {
    initializer_list<string> lst = {"a", "b", "c"};
    shared_ptr<initializer_list<string>> li = make_shared<initializer_list<string>>(lst);
    cout << *li->begin() << endl;


    int num =1;
    shared_ptr<int> pi = make_shared<int>(num);
    cout << *pi << endl;
    
//    StrBlob demo(lst);
//    cout << demo.front() << endl;

    return 0;
}

405 复习一下在类外定义构造函数

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
using namespace std;


class Sales_data{
public:
Sales_data();
Sales_data(const string &s);

string show_data(){
return this->data;
}

private:
string data;
};

// 没有传入string时候,初始化默认的data
Sales_data::Sales_data():data(string("sdds")){}
// 传入string时候初始化data
Sales_data::Sales_data(const string &s):data(s) {};


int main() {
Sales_data demo;
cout << demo.show_data() << endl;
return 0;
}

StrBlob类

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
using namespace std;


class StrBlob{
public:
    typedef std::vector<std::string>::size_type size_type;
    StrBlob();
    StrBlob(std::initializer_list<std::string> il);

    size_type size() const {return data->size();};
    bool empty() const {return data->empty();};

    void push_back(const std::string &t){data->push_back(t);};
    void pop_back();

    std::string& front();
    std::string& back();

private:
    std::shared_ptr<std::vector<std::string>> data;
    void check(size_type i, const std::string &msg) const;
};


StrBlob::StrBlob() :data(make_shared<vector<string>>()){}
StrBlob::StrBlob(initializer_list<string> il):data(make_shared<vector<string>>(il)){}
void StrBlob::check(size_type i, const std::string &msg) const {
    if (i>=data->size())
        throw out_of_range(msg);
}

string& StrBlob::front() {
    check(0, "front on empty StrBlob");
    return data->front();
}
string& StrBlob::back() {
    check(0, "back on empty StrBlob");
    return data->back();
}
void StrBlob::pop_back() {
    check(0, "pop_back on empty StrBlob");
    data->pop_back();
}


int main() {
    initializer_list<string> s = {"1", "2", "3"};
    StrBlob demo(s);
    cout << demo.front() << endl; //1
    cout << demo.back() << endl; //3
    demo.pop_back();
    cout << demo.size() << endl; // 2
    cout << demo.back() << endl; // 2

    return 0;
}

407 动态内存分配和初始化对象

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;



int main(){
    int *pi = new int;
    string *ps = new string;

    int *pi2 = new int(1024);
    string *ps2 = new string(10, '9');
    vector<int> *pv2 = new vector<int>{0, 1, 2, 3};


    string *ps3 = new string;
    string *ps4 = new string();
    int *pi3 = new int;
    int *pi4 = new int();

    int num1 = 2;
    int *pi5 = new auto(num1);

    const int *pci = new const int(1024);
    const string *pcs = new const string;


    return 0;
}

delete

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;



int main(){
    int *p1 = new int;
    int *p2 = new (nothrow) int;

    int num = 3;
    int *p3 = &num;
    // error
    // delete p3;

    int i, *pi1 = &i, *pi2 = nullptr;
    double *pd = new double(33), *pd2 = pd;
    // error
    // delete i;
    // error
//    delete pi1;
    delete pd;
    // error
//    delete pd2;
    delete pi2;

    return 0;
}

动态内存例子

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;



int main(){
    int *p1 = new int;
    int *p2 = new (nothrow) int;

    int num = 3;
    int *p3 = &num;
    // error
    // delete p3;

    int i, *pi1 = &i, *pi2 = nullptr;
    double *pd = new double(33), *pd2 = pd;
    // error
    // delete i;
    // error
//    delete pi1;
    delete pd;
    // error
//    delete pd2;
    delete pi2;

    const int *pci = new const int(1024);
    delete pci;

    return 0;
}

411 动态内存的坑

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;



int main(){
    int *p(new int(42));
    auto q = p;
    delete p;
    p = nullptr;
    // 释放了p以后,q已经为无效了,但是很难被察觉
    return 0;
    
}

12.6

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;


vector<int>* create(){
    return new vector<int>;
}


int main(){

    vector<int> *pv = create();

    vector<int> vec = {1, 2 ,3};
    for (auto val:vec){
        pv->push_back(val);
    }

    for (vector<int>::iterator iter=pv->begin(); iter!=pv->end(); ++iter){
        cout << *iter << " ";
    }
    delete pv;

    return 0;
}

12.7

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;


shared_ptr<vector<int>> create(){
    return make_shared<vector<int>>();
}


int main(){

    shared_ptr<vector<int>> pv = create();

    vector<int> vec = {1, 2 ,3};
    for (auto val:vec){
        pv->push_back(val);
    }

    for (vector<int>::iterator iter=pv->begin(); iter!=pv->end(); ++iter){
        cout << *iter << " ";
    }

    return 0;

}

412 智能指针和动态内存结合使用

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;

shared_ptr<int> clone(int p){

    return shared_ptr<int>(new int(p));
}


int main(){

    shared_ptr<double> p1;
    shared_ptr<int> p2(new int(42));

    // error
//    shared_ptr<int> p1 = new int(1024);
    shared_ptr<int> p3(new int(1024));
    return 0;

}

413 不要混合使用智能指针和普通指针

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;

void process(shared_ptr<int> ptr){

}

int main(){

//    shared_ptr<int> p(new int(42));
//    process(p);
//    int i = *p;

    // x is a normal pointer
    int *x(new int(1024));
    cout << *x << endl; // 1024
//    process(x);
    process(shared_ptr<int>(x));
    // x was released after process
    int j = *x;
    cout << j << endl; // null

    return 0;

}

判断智能指针是否共享对象

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
using namespace std;


int main(){
    shared_ptr<int> p(new int(42));
    int *q = p.get();

    {
        shared_ptr<int>(q);
    }
    cout << *p << endl;

//    p = new int(1024);
    p.reset(new int(1024));
    shared_ptr<int> p2 = p;

    if (!p.unique()){
        cout << "p not unique" << endl;
    }
    
    return 0;

}

12.14 重写share_ptr综合例子,连接程序

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
#include <string>
using namespace std;


struct destination{
    string des;
    destination(string des_): des(des_){}
};

struct connection{
    string conn;
    connection(string conn_): conn(conn_){}
};

connection connect(destination *des_){
    connection conn(des_->des);
    cout << "connect to " << des_->des << endl;
    return conn;
}

void disconnect(connection *conn){
    cout << "disconnect " << conn->conn << endl;

}

void end_connection(connection *p){
    // 固定格式
    disconnect(p);
}

void f(destination *des){
    connection conn = connect(des);
    
    // 固定格式
    shared_ptr<connection> p(&conn, end_connection);
    cout << "connecting " << des->des << " now" <<endl;

}


int main(){
    destination des("aa");
    f(&des);
    return 0;

}

12.15

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
#include <string>
using namespace std;


struct destination{
    string des;
    destination(string des_): des(des_){}
};

struct connection{
    string conn;
    connection(string conn_): conn(conn_){}
};

connection connect(destination *des_){
    connection conn(des_->des);
    cout << "connect to " << des_->des << endl;
    return conn;
}

void disconnect(connection *conn){
    cout << "disconnect " << conn->conn << endl;

}


void f(destination *des){
    connection conn = connect(des);
    // 固定格式
    shared_ptr<connection> p(&conn, [](connection *p){ disconnect(p);});
    cout << "connecting " << des->des << " now" <<endl;

}


int main(){
    destination des("aa");
    f(&des);
    return 0;

}

417 unique_ptr

#include<iostream>
#include<memory>
#include<string>

using namespace std;


int main() {
    unique_ptr<double> p1;
    unique_ptr<int> p2(new int(42));


    unique_ptr<string> p3(new string("aaabbbccc"));
    // error not support copying
//    unique_ptr<string> p4(p3);
    unique_ptr<string>p5;
    // error
//    p5 = p4;
    return 0;
}

unique_pt的控制权迁移

#include<iostream>
#include<memory>
#include<string>

using namespace std;


int main() {

    unique_ptr<string> p1(new string("ssss"));
    unique_ptr<string> p2(p1.release());
    unique_ptr<string> p3(new string("aaaa"));
    p2.reset(p3.release());

    cout << *p2 << endl;
    
    auto p = p2.release();
    delete p;
    return 0;
}

419 使用unique_ptr写连接程序

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
#include <string>
using namespace std;


struct destination{
    string des;
    destination(string des_): des(des_){}
};

struct connection{
    string conn;
    connection(string conn_): conn(conn_){}
};

connection connect(destination *des_){
    connection conn(des_->des);
    cout << "connect to " << des_->des << endl;
    return conn;
}

void disconnect(connection *conn){
    cout << "disconnect " << conn->conn << endl;

}

void end_connection(connection *p){
    // 固定格式
    disconnect(p);
}

void f(destination *des){
    connection conn = connect(des);

    // 固定格式
    unique_ptr<connection, decltype(end_connection)*> p(&conn, end_connection);
    cout << "connecting " << des->des << " now" <<endl;

}


int main(){
    destination des("aa");
    f(&des);

    return 0;

}

420 weak_ptr 弱共享

#include <iostream>
#include <memory>
#include <malloc.h>
#include <vector>
#include <string>
using namespace std;


int main(){
    auto p = make_shared<int>(42);
    shared_ptr<int> p2(p);
    weak_ptr<int> wp(p);
    cout << p.use_count() << endl;

    if (shared_ptr<int> np = wp.lock()){
        cout << *np << endl;
    }
    return 0;
}

12.19 - 12.20

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


class StrBlob{
public:
    friend class StrBlobPtr;
    StrBlobPtr begin();
    StrBlobPtr end();

    typedef std::vector<std::string>::size_type size_type;
    StrBlob();
    StrBlob(std::initializer_list<std::string> il);

    size_type size() const {return data->size();};
    bool empty() const {return data->empty();};

    void push_back(const std::string &t){data->push_back(t);};
    void pop_back();

    std::string& front();
    std::string& back();
    std::shared_ptr<std::vector<std::string>> data;

private:
    void check(size_type i, const std::string &msg) const;
};


StrBlob::StrBlob() :data(make_shared<vector<string>>()){}
StrBlob::StrBlob(initializer_list<string> il):data(make_shared<vector<string>>(il)){}
void StrBlob::check(size_type i, const std::string &msg) const {
    if (i>=data->size())
        throw out_of_range(msg);
}

string& StrBlob::front() {
    check(0, "front on empty StrBlob");
    return data->front();
}
string& StrBlob::back() {
    check(0, "back on empty StrBlob");
    return data->back();
}
void StrBlob::pop_back() {
    check(0, "pop_back on empty StrBlob");
    data->pop_back();
}

class StrBlobPtr{
public:
    StrBlobPtr():curr(0){}
    StrBlobPtr(StrBlob &a, size_t sz=0):wptr(a.data), curr(sz){}
    string& deref() const;
    StrBlobPtr& incr();

private:
    shared_ptr<vector<string>> check(size_t, const string&) const;
    weak_ptr<vector<string>> wptr;
    size_t curr;
};

//shared_ptr<vector<string>>;
shared_ptr<vector<string>> StrBlobPtr::check(size_t i, const string &msg) const {
    auto ret = wptr.lock();
    if (!ret){
        throw runtime_error("unbound StrBlobPtr");
    }
    if (i>=ret->size())
        throw out_of_range(msg);
    return ret;
}

string& StrBlobPtr::deref() const {
    auto p = check(curr, "dereference past end");
    return (*p)[curr];
}

StrBlobPtr& StrBlobPtr::incr() {
    check(curr, "increment past end of StrBlobPtr");
    ++curr;
    return *this;
}

StrBlobPtr StrBlob::begin(){
    return StrBlobPtr(*this);
}
StrBlobPtr StrBlob::end(){
    return StrBlobPtr(*this, data->size());
}


int main() {
    StrBlob stb;
    StrBlobPtr stbr(stb);
    ifstream in("items.txt");
    string text;
    while (getline(in ,text)){
        stb.push_back(text);
        cout << text << endl;
    }
    cout << endl;

    auto begin = stb.begin();
    auto end = stb.end();


    while(true){

        try{
            cout <<stbr.deref() << endl;
            stbr.incr();
        } catch (...) {
            cout << "end of data" << endl;
            break;
        }

    }

    return 0;
}

423 动态数组的创建

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    int *pia = new int[30];
    typedef int arrT[42];
    int *p = new arrT ;

    // init
    int *pia2 = new int[10]();  //  0 0 0 0 0 0 0 0 0 0

    for (size_t i=0; i!=10; ++i){
        cout << *(pia2+i) << " ";
    }
    cout << endl;

    int *pia3 = new int[10]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    string *psa3 = new string[10]{"a", "an", "the", string(3, 'x')}; //a an the xxx
    for (size_t i=0; i!=10; ++i){
        cout << *(psa3+i) << " ";
    }
    cout << endl;

    return 0;
}

425 释放动态数组

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    int *p = new int[10];
    delete [] p;

    int *p2 = new int[10]();
    delete [] p2;
    
    return 0;
}

426 智能指针与动态数组

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    unique_ptr<int[]> up(new int[10]);
    for (int i=0; i!=10; ++i){
        up[i] = i;
    }
    for (size_t i=0;i!=10;++i){
        cout << up[i] << " ";
    }
    cout << endl;
    up.release();

    shared_ptr<int> sp(new int [10], [](int *p){delete [] p;});
    sp.reset(new int[20]);

    for (size_t i=0; i!=10; ++i){
        *(sp.get() +i) = i;
    }
    for (size_t i=0; i!=10; ++i){
        cout << *(sp.get() +i) << " ";
    }
    cout << endl;
    return 0;
}

12.23

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    const char a[] = "aaa";
    const char b[] = "bbb";
    char *ans = new char[strlen(a) + strlen(b)];
    strcpy(ans, a);
    strcat(ans, b);

    for (size_t i=0; i!=strlen(ans) + 1; ++i){
        cout << ans[i] << " ";
    }
    delete[] ans;
    return 0;
}

12.24

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    const string a = "aaa";
    const string b = "bbb";
    string *ans = new string(a + b);
    for (auto item:*ans){
        cout << item << " ";
    }
    delete[] ans;

    return 0;
}

12.24

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    char *ch = new char[3];
    string s;
    cin >> s;
    strcpy(ch, s.c_str());

    for (size_t i=0; i!=3; ++i){
        cout << ch[i] << " ";
    }
    cout << endl;
    return 0;

}

427

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    size_t n = 5;
    string *const p = new string[n];
    string s;
    string *q = p;
    while (cin>>s && q != p + n){
        *q++ = s;
    }
    const size_t size = q - p;
    cout << size << endl;

    for (size_t i =0; i!=6; ++i){
        cout << p[i] << " ";
    }
    delete[] p;

    return 0;

}

427 使用allocate类动态分配内存,对象构造

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    // allocating memory
    size_t n = 6;
    allocator<string> alloc;
    auto const p = alloc.allocate(n);

    auto q = p;
//    alloc.construct(q++);
//    alloc.construct(q++, 5, 'c');
    alloc.construct(q++, "hi");

    cout << *p << endl;
    while (q!=p){
        alloc.destroy(--q);
    }

    alloc.deallocate(p, n);
   return 0;

}

429

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    vector<string> vi = {"a", "b", "c"};
    allocator<vector<string>> alloc;

    auto p = alloc.allocate(vi.size()*2);
    auto q = uninitialized_copy(vi.begin(), vi.end(), p);

    uninitialized_fill_n(q, vi.size(), 42);
    return 0;

}

12.26

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
using namespace std;


int main() {
    allocator<string> alloc;
    auto p = alloc.allocate(3);
    string s;
    auto q=p, r=p;

    while(cin>>s&&q!=p+3){
        alloc.construct(q++,s);
    }
    for (size_t i=0;i!=3; ++i){
        cout << *(r++) << " ";
    }
    cout << endl;
    while (q!=p){
        alloc.destroy(--q);
    }
    alloc.deallocate(p, 3);
    
    return 0;

}

430 文本查询程序的设计

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <set>
#include <iterator>
#include <memory>
#include <fstream>
#include <map>
#include <sstream>
using namespace std;
using line_no = vector<string>::size_type;



class QueryResult{
    friend ostream& print(ostream&, const QueryResult&);

public:
    QueryResult(string s,
                shared_ptr<set<line_no>> p,
                shared_ptr<vector<string>> f): sought(s), lines(p), file(f){}
private:
    string sought;
    shared_ptr<set<line_no>> lines;
    shared_ptr<vector<string>> file;
};


class TextQuery{
public:
    TextQuery(ifstream &);
    QueryResult query(const string&) const;

private:
    shared_ptr<vector<string>> file;
    map<string, shared_ptr<set<line_no>>> wm;
};
TextQuery::TextQuery(ifstream &is): file(new vector<string>) {
    string text;
    while (getline(is, text)){
        file->push_back(text);
        int n = file->size() - 1;
        istringstream line(text);
        string word;
        while (line>>word){
            auto &lines = wm[word];
            if (!lines)
                lines.reset(new set<line_no>);
            lines->insert(n);
        }
    }
}
QueryResult TextQuery::query(const string &sought) const {
    static shared_ptr<set<line_no>> nodata(new set<line_no>);
    auto loc = wm.find(sought);
    if (loc==wm.end()){
        return QueryResult(sought, nodata, file);
    } else{
        return QueryResult(sought, loc->second, file);
    }
}

string make_plural(size_t num, const string& input, const string& suffix){
    return (num > 1)? input+suffix:input;
}

ostream &print(ostream & os, const QueryResult &qr){
    os << qr.sought << " occurs " << qr.lines->size() << " " << make_plural(qr.lines->size(), "time", "s") << endl;
    for (auto  num:*qr.lines){
        os << "\t(line " << num+1 << ") " << *(qr.file->begin()+num) << endl;
    }
    return os;
}


void runQueries(ifstream &infile){
    TextQuery tq(infile);
    while (true){
        cout << "enter word to look for, or q to quit: ";
        string s;
        if (!(cin>>s)||s=="q") break;
        print(cout, tq.query(s)) << endl;
    }
}


int main() {
    ifstream in("input.txt");
    runQueries(in);
}
HELLOWORLD2424
关注
c++primer 智能指针基础
qq_34116958的博客
03-20 204
c++中的内存可分为三种，静态内存，堆内存(自由空间)，栈内存。 静态内存：用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量，由编译器自动创建核销毁，在使用前分配，在程序结束时销毁。 栈：保存函数内部的非static对象，由编译器自动创建核销毁，在其定义的程序块运行时存在。 堆：被称为动态分配，生存周期由程序控制，人为控制创建核销毁。 ...
C++ Primer第五版笔记——智能指针
rest_in_peace的博客
07-20 1041
智能指针 智能指针与常规指针的重要区别在于前者负责自动释放所指向的对象； 智能指针也是一种模板，需要提供可以指向的类型； 为了更容易的管理动态内存，新的标准库提供了两种智能指针类型： shared_ptr允许多个指针指向同一个对象； unique_ptr则“独占”所指向的对象。 标准库还定义了一个名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象。以上三...
C++ primer学习 12.19
steph_curry的博客
12-19 318
一、关联容器 关联容器通过键(key)存储和读取元素 1.1 pair类型 pairanon; anon=make_pair(string("aaa"),5);//不加STring(),vc6.0会报错 cout<<anon.first<<endl;//通过.first与.second访问元素 return 0; 2.2 map类型 a、加上#include 使用下标访问ma
C++ Primer 练习 12.19 - 12.22 题
是宿醉还是离别
06-14 663
现在 是 第十二章的部分练习： 12.19：     定义你自己版本的StrBlobPtr，更新StrBlob类，加入恰当的friend声明及begin和end成员了。     这题 为了方便 我直接写在一个头文件里。 //StrBlob.h #include #include #include #include #include using std::cout; using
C++primer5th课后题12.6、12.14、12.19
PIPIXIU的博客
11-14 526
//习题12.6 //返回动态分配的int的vector，传递给另一个函数，读取标准输入保存为vector元素中， /*shared_ptr<vector<int>> new_factor(void) { return make_shared<vector<int>>(); } vector<int> *new_vector(void) { return new (nothrow)
C++ Primer学习笔记详解
最新发布
09-14
内容概要：这是关于《C++ Primer学习笔记》的文章，涵盖多种类型转换、异常机制、类静态成员、IO库介绍、顺序容器操作、泛型算法应用、关联容器概念与使用详解、动态内存智能指针管理、构造函数与拷贝构造细节探讨、...
C++ Primer学习笔记：数组与指针、模板与面向对象编程
这篇学习笔记涵盖了C++ Primer中的多个重要概念，主要包括数组和指针的使用以及模板、面向对象编程和操作符重载的概念。 1. **数组** - 数组是一种存储相同类型数据的集合，一旦定义，其大小不可变。 - 定义数组...
《C++ Primer》读书笔记第十二章-1-动态内存与智能指针
陈云佳的专栏
09-24 506
笔记会持续更新，有错误的地方欢迎指正，谢谢!这章是特别特别不想写的Emmmmmm这一章–>内存 全局对象在程序启动时分配内存，在程序结束时销毁； 对于局部自动对象，当我们进入其定义所在的程序块时被创建，在离开块时销毁； 局部static对象在第一次使用前分配，在程序结束时才销毁。 这些都是C++ 编译器帮我们管理的，对于这么爱赋予程序员自由的语言，C++也允许我们自己来决定，就是动态分配对象：动态分
《C++ Primer Plus 第6版》第16章 string类和标准模板库 学习笔记——智能指针模板类
Anna_L的博客
12-23 308
智能指针模板类
C++ Primer 学习笔记——动态内存和智能指针（2）
我是要成为海贼王的男人！
03-04 284
动态数组使用new创建动态数组，返回指向第一个对象的指针int *pia=new int[get_size()];当new分配一个数组时候，并未得到数组类型的对象，而是得到一个数组类型元素的指针，没有begin没有end也不能用for语句处理int *pia=new int[10]{1,2,3,4,5,6,7,8,9,10}; int *pia2=new int[10]():释放指针 delete
C++ primer 第五版 中文版 练习 12.20 个人code
jierandefeng的专栏
09-27 1322
C++ primer 第五版 中文版 练习 12.20  题目：
C/C++内存泄漏及检测
angellove156的专栏
10-08 690
通过以下例子来介绍如何检测内存泄漏问题： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include #include using namespace std;    void GetMemory(char *p, int nu
CLION CMAKE 缺-g 导致断点不执行（无效）
insanegtp的博客
12-18 1885
这个与CLION没关系，就是我在用CLION时设置了断点，死活不执行断点，直接跳过去。网上查了，有的说是debug没选好（bundled gbd，bundled lldb）对我没用。有的说是没设置debug模式要加set(CMAKE_BUILD_TYPE Debug)，对我也没用。后来找到一个帖子说cmake_cxx_flags 少-g，确实如此。 SET(CMAKE_CXX_FLAGS "${...
关于C++中的内存泄露
weixin_30399055的博客
03-30 106
1.c++内存泄漏的定义： 内存泄漏(memory leak)是指由于疏忽或错误造成了程序未能释放掉不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。 2.内存泄漏的后果： 最难捉摸也最难检测到的错误之一是内存泄漏，即未能正确释放以前分配的内存的 bug。 只发生一次的小的内存泄漏可能不会被注意，但泄漏大...
C++ Primer 第四版学习笔记.rar
12-05
《C++ Primer 第四版学习笔记》是一份深入学习C++编程语言的宝贵资源，它由一位经验丰富的学习者在2014年整理而成，旨在帮助初学者更有效地掌握C++的基础和进阶概念。这份笔记以清晰、实用的方式阐述了C++ Primer第...
c++Primer第12章：动态内存与智能指针
qq_50271250的博客
10-31 269
12.1.1节练习 12.1：在此代码的结尾，b1和b2各包含多少个元素？ StrBlob b1; { StrBolb b2={"a","b","the"}; b1=b2; b2.push_back("about"); } 答：考虑到是智能指针，所以会共享内存，所以都是4个 12.2:编写你自己的StrBlob类，包含const版本的front和back 答： class StrBlob { public : typedef std::vector<std::string>::size
java内存泄漏
YangYoung_的博客
10-10 1507
所谓的内存泄漏不是说内存坏掉了，内存溜出去了，而是因为线程进行中一直占用了某块内存无法进行GC，这块内存之后永远都无法被使用，导致这块内存像是没有了一样，嗯哼
关于用函数指针参数申请动态内存的问题
码莎拉蒂
07-02 2969
今天在写一个Binary Search Tree的程序时，发现其插入有问题，下面是插入程序，每次插入完成后，节点还是NULL。 template void CMyTree::insert(const Object& element, BinaryNode* node) { if(node == NULL) node = new BinaryNode(element); //新
C申请内存函数
桀骜不逊
02-23 355
#include <iostream> using namespace std;//传值调用 void GetMemory( char **p ) { *p = (char *) malloc( 100 ); } //引用调用 void GetMemory_1(char *&p) { p = (char *) malloc (100); }int main() { char
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值