《C++ Primer》导学系列:第 12 章 - 动态内存

ROS四旋翼无人机快速上手指南(4):阿木实验室PX4功能包飞行控制分析与讲解(重点章节) 成就更好的自己 这一章详细讲解一下阿木实验室(AMOV)的开源项目px4_command功能包,此功能包通过mavlink协议直接控制烧录px4固件的自驾仪,还融合了来自各个传感器的位姿,距离等信息,此外,功能包提供的接口向上对接应用层算法级的程序例如SLAM,kfc目标检测引导,路径规划等算法,因此,在整个无人机控制中起到了承上启下至关重要的作用。 用到的文件及工具包链接如下: AMOV实验室源码如下: https://gitee.com/theroadofengineers/px4_comman 阅读详情

12.1 动态内存与智能指针

动态内存管理是C++编程中的重要部分。使用动态内存时,程序员需要手动分配和释放内存,这可能导致内存泄漏和其他问题。为了解决这些问题,C++11引入了智能指针(smart pointers),它们自动管理动态内存的生命周期。本节将介绍动态内存管理的基本概念以及智能指针的使用。

12.1.1 直接管理内存

在C++中,可以使用new和delete操作符来分配和释放动态内存。

  • new:分配动态内存并返回指向该内存的指针。
  • delete:释放先前使用new分配的动态内存。
示例代码
#include <iostream>

int main() {
    // 使用new分配动态内存
    int* p = new int(42);

    // 输出动态内存中的值
    std::cout << "Value: " << *p << std::endl;

    // 使用delete释放动态内存
    delete p;

    return 0;
}

直接管理内存的缺点包括需要手动释放内存,容易导致内存泄漏和悬空指针(dangling pointer)的问题。因此,使用智能指针来管理动态内存是一个更好的选择。

12.1.2 shared_ptr

shared_ptr是C++标准库中的智能指针类型之一,用于共享所有权。多个shared_ptr实例可以共享同一个对象,当最后一个shared_ptr被销毁时,对象的内存会被自动释放。

示例代码
#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> p1 = std::make_shared<int>(42);
    std::cout << "Shared_ptr value: " << *p1 << std::endl;
    std::shared_ptr<int> p2 = p1; // p1和p2共享同一个对象
    std::cout << "Use count: " << p1.use_count() << std::endl;

    return 0;
}

12.1.3 shared_ptr与new结合使用

虽然推荐使用std::make_shared来创建shared_ptr,但也可以直接与new结合使用。这种方式需要注意,在创建shared_ptr时要确保对象的内存被正确管理。

示例代码
#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> p1(new int(42));
    std::cout << "Shared_ptr value: " << *p1 << std::endl;
    std::shared_ptr<int> p2 = p1; // p1和p2共享同一个对象
    std::cout << "Use count: " << p1.use_count() << std::endl;

    return 0;
}

12.1.4 unique_ptr

unique_ptr是独占所有权的智能指针,不能被复制,只能被移动。这意味着在同一时间只能有一个unique_ptr指向特定对象。使用unique_ptr可以确保动态内存不会被多个指针同时管理,从而避免了双重释放的问题。

示例代码
#include <iostream>
#include <memory>

void useUniquePtr() {
    std::unique_ptr<int> p1(new int(42));
    std::cout << "Value: " << *p1 << std::endl;

    // 将所有权转移给另一个unique_ptr
    std::unique_ptr<int> p2 = std::move(p1);
    if (!p1) {
        std::cout << "p1 is null after move" << std::endl;
    }
    std::cout << "Value after move: " << *p2 << std::endl;
}

int main() {
    useUniquePtr();
    return 0;
}

12.1.5 weak_ptr

weak_ptr是一种弱引用智能指针,不影响shared_ptr的引用计数。它通常与shared_ptr一起使用,以避免循环引用导致的内存泄漏。weak_ptr不能直接访问对象,需要先将其转换为shared_ptr。

示例代码
#include <iostream>
#include <memory>

void useWeakPtr() {
    std::shared_ptr<int> sp = std::make_shared<int>(42);
    std::weak_ptr<int> wp = sp; // wp是sp的弱引用
    std::cout << "Use count before reset: " << sp.use_count() << std::endl;

    sp.reset(); // 释放sp持有的对象

    if (wp.expired()) {
        std::cout << "Weak pointer is expired" << std::endl;
    } else {
        std::shared_ptr<int> sp2 = wp.lock(); // 将wp转换为shared_ptr
        std::cout << "Value: " << *sp2 << std::endl;
    }
}

int main() {
    useWeakPtr();
    return 0;
}

12.1.6 智能指针与异常

智能指针在异常处理时尤为有用。由于智能指针会自动释放所管理的内存,因此可以防止因异常抛出导致的内存泄漏。

示例代码
#include <iostream>
#include <memory>

void mayThrow() {
    throw std::runtime_error("An error occurred");
}

void useSmartPointerWithException() {
    std::shared_ptr<int> sp = std::make_shared<int>(42);
    try {
        mayThrow();
    } catch (const std::exception& e) {
        std::cout << "Exception caught: " << e.what() << std::endl;
    }
    std::cout << "Value: " << *sp << std::endl;
}

int main() {
    useSmartPointerWithException();
    return 0;
}

在上述代码中,即使mayThrow函数抛出异常,智能指针sp也会确保在其作用域结束时正确释放内存。

重点与难点分析

重点:

  1. 理解动态内存分配与释放:掌握new和delete操作符的使用。
  2. 掌握智能指针的基本概念和使用方法:了解std::unique_ptr、std::shared_ptr和std::weak_ptr的特点和用法。
  3. 避免内存泄漏和双重释放:通过使用智能指针自动管理内存,减少内存管理错误。

难点:

  1. 智能指针的所有权管理:理解std::unique_ptr的独占所有权和std::shared_ptr的共享所有权。
  2. 循环引用问题的解决:了解如何使用std::weak_ptr避免std::shared_ptr之间的循环引用。

练习题解析

  1. 练习12.1:编写一个程序,使用std::unique_ptr管理动态分配的整数,并输出其值。
    • 示例代码:
#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> p(new int(42));
    std::cout << "Value: " << *p << std::endl;

    return 0;
}
  1. 练习12.2:编写一个程序,使用std::shared_ptr管理动态分配的字符串,并输出其值和引用计数。
    • 示例代码:
#include <iostream>
#include <memory>
#include <string>

int main() {
    std::shared_ptr<std::string> p1 = std::make_shared<std::string>("Hello, World!");
    std::shared_ptr<std::string> p2 = p1; // p1和p2共享同一个字符串

    std::cout << "Value: " << *p1 << std::endl;
    std::cout << "Use count: " << p1.use_count() << std::endl;

    return 0;
}
  1. 练习12.3:编写一个程序,使用std::weak_ptr和std::shared_ptr避免循环引用,验证std::weak_ptr的有效性。
    • 示例代码:
#include <iostream>
#include <memory>

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;
};

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>();
    std::shared_ptr<Node> node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1;

    std::cout << "Node1 use count: " << node1.use_count() << std::endl;
    std::cout << "Node2 use count: " << node2.use_count() << std::endl;

    node1.reset();
    node2.reset();

    return 0;
}

总结与提高

本节总结:

  1. 了解了动态内存分配与释放的基本概念和操作,掌握了new和delete的使用方法。
  2. 理解了智能指针的基本概念,掌握了std::unique_ptr、std::shared_ptr和std::weak_ptr的使用方法。
  3. 通过智能指针的使用,能够有效避免内存泄漏和双重释放问题,提高了程序的可靠性和稳定性。

提高建议:

  1. 多练习智能指针的使用:通过编写更多涉及智能指针的程序,熟悉各种智能指针的用法,提高对动态内存管理的能力。
  2. 深入理解智能指针的原理:通过阅读文档和相关书籍,深入理解智能指针的实现原理和使用场景,提高编写高效代码的能力。
  3. 避免常见内存管理错误:在实际项目中,尽量使用智能指针管理动态内存,避免手动管理内存带来的错误,提高代码的可读性和可维护性。

12.2 动态数组

动态数组是指在运行时动态分配内存来存储数组元素的技术。在C++中,动态数组通常使用new和delete[]操作符来管理其内存。尽管可以直接使用这些操作符进行内存管理,但标准库提供的容器类(如std::vector)更为方便和安全。

12.2.1 使用new和delete[]管理动态数组

可以使用new操作符为动态数组分配内存,并使用delete[]操作符释放该内存。下面是一个基本示例,展示了如何分配和释放动态数组:

示例代码
#include <iostream>

int main() {
    // 使用new分配动态数组
    int* arr = new int[5];

    // 初始化数组
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 2;
    }

    // 输出数组元素
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // 使用delete[]释放动态数组
    delete[] arr;

    return 0;
}

12.2.2 使用智能指针管理动态数组

智能指针可以用来管理动态数组的生命周期,以避免手动释放内存带来的问题。C++11引入的std::unique_ptr可以用来管理动态数组。

示例代码
#include <iostream>
#include <memory>

int main() {
    // 使用unique_ptr管理动态数组
    std::unique_ptr<int[]> arr(new int[5]);

    // 初始化数组
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 2;
    }

    // 输出数组元素
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // 无需手动释放内存,unique_ptr会自动管理

    return 0;
}

12.2.3 使用std::vector管理动态数组

虽然可以直接使用new和delete[]来管理动态数组,但使用标准库中的std::vector通常是更好的选择。std::vector是一个动态数组容器,提供了许多方便的成员函数来管理数组元素的添加、删除和访问。

示例代码
#include <iostream>
#include <vector>

int main() {
    // 使用vector管理动态数组
    std::vector<int> vec(5);

    // 初始化数组
    for (int i = 0; i < 5; ++i) {
        vec[i] = i * 2;
    }

    // 输出数组元素
    for (int i = 0; i < 5; ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;

    // vector会自动管理内存,无需手动释放

    return 0;
}

12.2.4 allocator类

C++标准库提供了allocator类,用于更灵活和低级别的内存管理。allocator类允许我们分配未初始化的内存,并在其中构造对象。

示例代码
#include <iostream>
#include <memory>

int main() {
    std::allocator<int> alloc;  // 创建allocator对象

    int* arr = alloc.allocate(5);  // 分配未初始化的内存

    for (int i = 0; i < 5; ++i) {
        alloc.construct(&arr[i], i * 2);  // 在分配的内存中构造对象
    }

    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    for (int i = 0; i < 5; ++i) {
        alloc.destroy(&arr[i]);  // 销毁对象
    }
    alloc.deallocate(arr, 5);  // 释放内存

    return 0;
}

重点与难点分析

重点:

  1. 动态数组的基本操作:掌握使用new和delete[]分配和释放动态数组内存的方法。
  2. 智能指针的应用:理解如何使用std::unique_ptr管理动态数组的内存。
  3. 标准库容器的使用:熟悉std::vector的用法,理解其在动态数组管理中的优势。
  4. allocator类的使用:学习使用allocator类进行更灵活的内存管理。

难点:

  1. 手动内存管理的注意事项:在使用new和delete[]时,确保正确匹配,避免内存泄漏和未定义行为。
  2. 智能指针与原生指针的区别:理解智能指针如何自动管理内存,避免手动释放带来的问题。
  3. 选择合适的工具:在实际编程中,根据具体需求选择使用原生指针、智能指针或标准库容器。
  4. 低级内存管理:理解和使用allocator类进行手动内存管理。

练习题解析

  1. 练习12.4:编写一个程序,使用new和delete[]管理动态分配的数组,并输出其元素。
    • 示例代码:
#include <iostream>

int main() {
    int* arr = new int[5];
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 2;
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    delete[] arr;
    return 0;
}
  1. 练习12.5:编写一个程序,使用std::unique_ptr管理动态分配的数组,并输出其元素。
    • 示例代码:
#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int[]> arr(new int[5]);
    for (int i = 0; i < 5; ++i) {
        arr[i] = i * 2;
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}
  1. 练习12.6:编写一个程序,使用std::vector管理动态分配的数组,并输出其元素。
    • 示例代码:
#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec(5);
    for (int i = 0; i < 5; ++i) {
        vec[i] = i * 2;
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}
  1. 练习12.7:编写一个程序,使用allocator类管理动态分配的数组,并输出其元素。
    • 示例代码:
#include <iostream>
#include <memory>

int main() {
    std::allocator<int> alloc;
    int* arr = alloc.allocate(5);
    for (int i = 0; i < 5; ++i) {
        alloc.construct(&arr[i], i * 2);
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    for (int i = 0; i < 5; ++i) {
        alloc.destroy(&arr[i]);
    }
    alloc.deallocate(arr, 5);
    return 0;
}

总结与提高

本节总结:

  1. 了解了动态数组的基本概念和操作,掌握了使用new和delete[]管理动态数组的方法。
  2. 理解了智能指针在动态数组管理中的应用,掌握了使用std::unique_ptr管理动态数组的方法。
  3. 熟悉了std::vector的用法,理解了其在动态数组管理中的优势。
  4. 学习了allocator类的使用,掌握了更灵活的内存管理技术。

提高建议:

  1. 多练习动态数组的管理:通过编写更多涉及动态数组管理的程序,熟

悉各种管理方法的用法,提高对动态内存管理的能力。
2. 深入理解智能指针的原理:通过阅读文档和相关书籍,深入理解智能指针的实现原理和使用场景,提高编写高效代码的能力。
3. 优先使用标准库容器:在实际项目中,尽量使用std::vector等标准库容器管理动态数组,以减少手动内存管理带来的错误,提高代码的可读性和可维护性。
4. 掌握低级内存管理技巧:通过练习使用allocator类,掌握更加灵活和低级的内存管理技巧,以应对复杂的内存管理需求。

12.3 使用标准库:文本查询程序

这一小节将通过一个实际的文本查询程序示例,来演示如何使用C++标准库中的容器和算法处理动态内存。我们将实现一个简单的文本查询程序,能够读取一个文件,并允许用户查询文件中的某个单词在文中出现的次数及其所在行。

12.3.1 程序概述

文本查询程序将分为以下几个部分:

  1. 读取文件:读取文件内容并存储每行文本。
  2. 构建索引:创建一个索引,将每个单词映射到它出现的行号集合。
  3. 查询单词:允许用户输入一个单词,程序返回该单词出现的次数及其所在行。
示例代码
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <map>
#include <set>

class TextQuery {
public:
    TextQuery(std::ifstream &infile);
    std::set<int> query(const std::string &word) const;
    void display_results(const std::set<int> &lines, const std::string &word) const;
private:
    std::vector<std::string> file;  // 存储文件每行文本
    std::map<std::string, std::set<int>> word_map;  // 单词到行号的映射
};

TextQuery::TextQuery(std::ifstream &infile) {
    std::string line;
    int line_number = 0;
    while (std::getline(infile, line)) {
        file.push_back(line);
        std::istringstream iss(line);
        std::string word;
        while (iss >> word) {
            word_map[word].insert(line_number);
        }
        ++line_number;
    }
}

std::set<int> TextQuery::query(const std::string &word) const {
    auto it = word_map.find(word);
    if (it != word_map.end()) {
        return it->second;
    } else {
        return std::set<int>();
    }
}

void TextQuery::display_results(const std::set<int> &lines, const std::string &word) const {
    std::cout << "The word \"" << word << "\" occurs " << lines.size() << " times:" << std::endl;
    for (int num : lines) {
        std::cout << "\t(line " << num + 1 << ") " << file[num] << std::endl;
    }
}

int main() {
    std::ifstream infile("text.txt");
    if (!infile) {
        std::cerr << "Could not open the file!" << std::endl;
        return 1;
    }

    TextQuery tq(infile);
    while (true) {
        std::cout << "Enter a word to search for, or q to quit: ";
        std::string word;
        if (!(std::cin >> word) || word == "q") break;
        std::set<int> results = tq.query(word);
        tq.display_results(results, word);
    }
    return 0;
}

12.3.2 详细分析

读取文件

程序首先打开一个文件,并逐行读取文件内容,将每行文本存储在一个std::vector<std::string>中。这使得我们能够在查询时轻松访问和显示每行内容。

构建索引

在读取每行文本时,程序使用std::istringstream将行文本分解为单词,并将每个单词插入到一个std::map<std::string, std::set<int>>中,其中std::string是单词,std::set<int>是单词出现的行号集合。使用std::set可以确保每个行号只出现一次。

查询单词

查询功能通过查找std::map中的单词来实现。如果找到单词,则返回其对应的行号集合;否则,返回一个空的std::set<int>。

显示结果

显示结果的函数接受一个行号集合和一个单词,然后输出该单词出现的次数及其所在行的内容。

重点与难点分析

重点:

  1. 使用标准库容器:熟悉std::vector、std::map和std::set的用法,并理解它们在不同场景下的作用。
  2. 文件输入输出:掌握如何使用std::ifstream读取文件内容,并使用std::istringstream解析每行文本。
  3. 查询与显示:理解如何高效地进行单词查询,并显示查询结果。

难点:

  1. 索引构建:确保每个单词正确映射到其出现的所有行号,并处理重复单词和行号。
  2. 查询效率:利用std::map和std::set的特性,确保查询操作的高效性。
  3. 动态内存管理:虽然标准库容器自动管理内存,但理解其背后的动态内存分配机制对于写出高效的代码仍然重要。

练习题解析

  1. 练习12.8:编写一个程序,读取一个文本文件,并输出文件中每个单词出现的次数。
    • 示例代码:
#include <iostream>
#include <fstream>
#include <sstream>
#include <map>

int main() {
    std::ifstream infile("text.txt");
    if (!infile) {
        std::cerr << "Could not open the file!" << std::endl;
        return 1;
    }

    std::map<std::string, int> word_count;
    std::string line;
    while (std::getline(infile, line)) {
        std::istringstream iss(line);
        std::string word;
        while (iss >> word) {
            ++word_count[word];
        }
    }

    for (const auto &pair : word_count) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}
  1. 练习12.9:修改文本查询程序,使其能够忽略大小写。
    • 示例代码:
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>

class TextQuery {
public:
    TextQuery(std::ifstream &infile);
    std::set<int> query(const std::string &word) const;
    void display_results(const std::set<int> &lines, const std::string &word) const;
private:
    std::vector<std::string> file;
    std::map<std::string, std::set<int>> word_map;

    static std::string to_lower(const std::string &str);
};

TextQuery::TextQuery(std::ifstream &infile) {
    std::string line;
    int line_number = 0;
    while (std::getline(infile, line)) {
        file.push_back(line);
        std::istringstream iss(line);
        std::string word;
        while (iss >> word) {
            word = to_lower(word);
            word_map[word].insert(line_number);
        }
        ++line_number;
    }
}

std::set<int> TextQuery::query(const std::string &word) const {
    auto it = word_map.find(to_lower(word));
    if (it != word_map.end()) {
        return it->second;
    } else {
        return std::set<int>();
    }
}

void TextQuery::display_results(const std::set<int> &lines, const std::string &word) const {
    std::cout << "The word \"" << word << "\" occurs " << lines.size() << " times:" << std::endl;
    for (int num : lines) {
        std::cout << "\t(line " << num + 1 << ") " << file[num] << std::endl;
    }
}

std::string TextQuery::to_lower(const std::string &str) {
    std::string lower_str = str;
    std::transform(lower_str.begin(), lower_str.end(), lower_str.begin(), ::tolower);
    return lower_str;
}

int main() {
    std::ifstream infile("text.txt");
    if (!infile) {
        std::cerr << "Could not open the file!" << std::endl;
        return 1;
    }

    TextQuery tq(infile);
    while (true) {
        std::cout << "Enter a word to search for, or q to quit: ";
        std::string word;
        if (!(std::cin >> word) || word == "q") break;
        std::set<int> results = tq.query(word);
        tq.display_results(results, word);
    }
    return 0;
}
  1. 练习12.10:编写一个程序,允许用户查询多个单词,并显示每个单词出现的次数及其所在行。
    • 示例代码:
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <map>
#include <set>

class TextQuery {
public:
    TextQuery(std::ifstream &infile);
    std::map<std::string, std::set<int>> query(const std::vector<std::string> &words) const;
    void display_results(const std::map<std::string, std::set<int>> &results) const;
private:
    std::vector<std::string> file;
    std::map<std::string, std::set<int>> word_map;
};

TextQuery::TextQuery(std::ifstream &infile) {
    std::string line;
    int line_number = 0;
    while (std::getline(infile, line)) {
        file.push_back(line);
        std::istringstream iss(line);
        std::string word;
        while (iss >> word) {
            word_map[word].insert(line_number);
        }
        ++line_number;
    }
}

std::map<std::string, std::set<int>> TextQuery::query(const std::vector<std::string> &words) const {
    std::map<std::string, std::set<int>> results;
    for (const auto &word : words) {
        auto it = word_map.find(word);
        if (it != word_map.end()) {
            results[word] = it->second;
        }
    }
    return results;
}

void TextQuery::display_results(const std::map<std::string, std::set<int>> &results) const {
    for (const auto &pair : results) {
        std::cout << "The word \"" << pair.first << "\" occurs " << pair.second.size() << " times:" << std::endl;
        for (int num : pair.second) {
            std::cout << "\t(line " << num + 1 << ") " << file[num] << std::endl;
        }
    }
}

int main() {
    std::ifstream infile("text.txt");
    if (!infile) {
        std::cerr << "Could not open the file!" << std::endl;
        return 1;
    }

    TextQuery tq(infile);
    while (true) {
        std::cout << "Enter words to search for, separated by spaces, or q to quit: ";
        std::string line;
        if (!std::getline(std::cin, line) || line == "q") break;
        std::istringstream iss(line);
        std::vector<std::string> words;
        std::string word;
        while (iss >> word) {
            words.push_back(word);
        }
        auto results = tq.query(words);
        tq.display_results(results);
    }
    return 0;
}

总结与提高

本节总结:

  1. 通过实现一个实际的文本查询程序,了解了如何使用C++标准库中的容器和算法处理动态内存。
  2. 掌握了文件输入输出、字符串处理、容器的使用和查询结果的显示。
  3. 理解了如何高效地构建索引,以便快速查询和显示结果。

提高建议:

  1. 多练习实际项目:通过更多实际项目练习,巩固对标准库容器和算法的使用,提高代码编写能力。
  2. 优化程序性能:在实际项目中,考虑程序的性能优化,如使用更高效的数据结构和算法。
  3. 深入理解标准库:通过阅读文档和相关书籍,深入理解C++标准库的各个组件及其使用场景,提高编写高效代码的能力。

本主页会定期更新,为了能够及时获得更新,敬请关注我:点击左下角的关注。也可以关注公众号:请在微信上搜索公众号“AI与编程之窗”并关注,或者扫描以下公众号二维码关注,以便在内容更新时直接向您推送。 

执行HDevelop项目 这一节,我们讲述的是如何用HDevEngine加载和执行一个HDevelop项目。代码部分来源于示例程序exec_program(源文件exec_program.cpp),检测塑料零件边界上的毛刺。1.Step 1:初始化首先,我们包含HALCON/C++和HDevEngine头文件以及命名空间。注意到在这个示例程序中,HDevEngine头文件已经包含在my_hdevoperatorimpl中,所 阅读详情

相关推荐

大麦APP抢票协议分析:从‘掌密网络’代码看移动端API安全防护

本文深度解析了大麦APP抢票协议的安全防护体系,重点分析了'掌密网络'代码中体现的动态签名、设备指纹和人机验证等关键技术。文章详细介绍了大麦APP如何通过多层次API安全防护应对抢票压力,包括参数加密、请求头部设计和异常处理机制,为移动应用开发者提供了安全实践建议。

weixin_28740299的博客 296

C++ primer 第十二章

提取重点

sskdspdl的博客 1011

硬件工程师八大细分岗位详解:从芯片到整机的技术分工与职业选择

硬件工程作为电子系统设计的核心领域,涉及从芯片级到整机级的完整技术链条。其基本原理是通过电路设计、信号处理和功率管理等技术,将电子元件集成为功能完备的硬件系统。随着产品复杂度提升,硬件工程师岗位出现高度专业化分工,这种细分不仅提升了技术深度,更优化了团队协作效率。在工程实践中,信号完整性和电源完整性成为高速数字设计的两个关键技术挑战,直接影响系统稳定性。本文基于行业热词"硬件工程师"和"信号完整性",深入解析八大细分岗位的技术差异,帮助从业者明确职业发展方向,构建系统化的硬件设计思维。

weixin_33811539的博客 459

C++ primer 动态内存与智能指针

文章目录一、动态内存1、了解OS的进程空间模型2、brk、mmap 系统调用3、malloc/free 是libc库函数4、new/new[]/delete/delete[]二、智能指针1、智能指针背后的设计思想2、普通指针存在的问题3、shared_ptr类(1)make_shared函数(2)shared_ptr的拷贝和赋值(3)shared_ptr自动销毁所管理的对象(4)使用动态内存的原因...

weixin_43282440的博客 249

使用html和JavaScript实现一个简易的物业管理系统

码实现了一个简易的物业管理系统,主要使用了以下技术和功能: 1.主要技术 使用的技术: HTML: 用于构建网页的基本结构。 包括表单、表格、按钮等元素。 CSS: 用于美化网页的外观和布局。 设置字体、颜色、边距、对齐方式等样式。 JavaScript: 用于处理用户交互和动态更新页面内容。 实现了新增住户、查询住户、编辑住户、删除住户等功能。 处理表单提交事件,验证输入数据,并更新表格显示。 DOM操作: 使用 JavaScript 直接操作 HTML DOM 元素。 动态

weixin_41312759的博客 1781

DeepBSA实战指南:从安装到基因组分析的全流程解析

本文详细解析了DeepBSA工具从安装到基因组分析的全流程,特别介绍了其简化生物信息学分析的'一键式'操作和独家深度学习算法。通过实战案例展示了DeepBSA在信噪比处理和QTL定位上的优势,并提供了Linux和Windows系统的安装避坑指南、数据预处理技巧以及算法选择建议,帮助用户高效完成基因组分析。

weixin_28732953的博客 448

C++ Primer 第五版 第12章 动态内存

定义一个名为StrBlob的类,保存一组元素。与容器不同,我们希望StrBlob对象的不同拷贝之间共享相同的元素。即,当我们拷贝一个StrBlob时,原StrBlob对象及其拷贝应该引用相同的底层元素。我们使用vector来保存元素。将vector保存在动态内存中,为每个StrBlob设置一个shared_ptr来管理动态分配的vector。次shared_ptr的成员将记录有多少个StrBlob共享相同的vector,并在vector的最后一个使用者销毁时释放vector。StrBlob构造函数。

weixin_44500921的博客 867

R 语言 ggplot2 绘制精美高级全球地图

在本教程中,我们将学习如何使用R语言和ggplot2包绘制精美高级地图。ggplot2是一个功能强大的数据可视化包,它可以让我们创建漂亮、交互式的地图。我们将使用R中的一些其他包来处理地理空间数据,以便与ggplot2无缝协作。

Mrrunsen的博客 1870

C++ Primer学习笔记-----第十二章:动态内存

new在动态内存中为对象分配空间并返回一个指向该对象的指针,可以对对象进行初始化。静态内存保存局部static对象、类static数据成员、定义在任何函数之外的变量。为了更容易更安全地使用动态内存,新的标准提供了两种只能指针类型来管理动态对象。delete接受一个动态对象的指针,销毁该对象,并释放与之关联的内存。只能指针的行为类似常规指针,重要的区别是它负责自动释放所指向的对象。C++Primer学习笔记-----第十二章动态内存。栈内存保存定义在函数内的非static对象。......

weixin_41155760的博客 585

AI智能体在零售行业的5大变革性应用

本文旨在全面介绍AI智能体在零售行业的关键应用场景,分析其技术原理和商业价值,帮助读者理解这些技术如何改变传统零售模式。文章将从核心概念入手,逐步深入五大应用场景的技术实现,最后探讨未来趋势和挑战。AI智能体:能够感知环境、做出决策并执行行动的智能软件实体机器学习:让计算机从数据中学习模式而无需显式编程的技术深度学习:基于神经网络的机器学习方法,能够处理复杂模式识别核心概念回顾AI智能体是零售数字化转型的关键驱动力从推荐系统到库存管理,AI正在重塑每个零售环节。

AI 原生应用开发的博客 1353

RH850从0搭建Autosar开发环境【6】- Davinci Configurator之CanIf模块配置详解(下)

RH850从0搭建Autosar开发环境【6】- Davinci Configurator之CanIf模块配置详解(下)

weixin_42412049的博客 2586

C++ primer 第12章:动态内存。个人学习笔记。

c++ primer 第12章 动态内存 个人学习笔记

weixin_45154969的博客 406

《拉依达的嵌入式\驱动面试宝典》—Linux篇(八)_Linux驱动编程

《拉依达的嵌入式\驱动面试宝典》 整合了所有我认为可能遇到的技术面试问题。所有问题及其答案均是我个人学习后查阅资料总结,每个回答都做了仔细的分析,在嵌入式及其驱动面试相关问题解析做到全网独一无二。学习或者转行到嵌入式、驱动开发领域学习的不二之选

拉依达不拉跨的博客 322

《C++ Primer》第五版导学系列:导言

C++ Primer》第五版是由Stanley B. Lippman、Josée Lajoie和Barbara E. Moo合著的一本经典教材。自首次出版以来,这本书一直被誉为学习C++编程语言的圣经。第五版在前几版的基础上,进行了全面更新,以适应C++11标准的最新特性和改进。通过阅读这本书,读者将获得对C++语言的深刻理解,掌握从基础语法到高级编程技术的全面知识。

iShare_Carlos的博客 1483

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

《C++ Primer》 第十二章 动态内存

《C++ Primer》 第十二章 动态内存

qq_44901656的博客 1212

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

C++_Primer_学习笔记_第十二章(动态内存)

第十二章(动态内存) 1).动态分配对象的生存期和它们在哪里创建是没有关系的,只有显式地被释放时,这些对象才会被释放。 2).为了解决动态对象能够被正确释放的问题,设置了智能指针。当一个对象应该被释放时,指向它的智能指针可以确保自动地释放它。 3).静态内存。 局部static变量。 类的static数据成员 全局变量 4).栈内存。保存局部变量。 5).静态内存和栈内存,由编译器自动创建和销毁。 6).程序的自由空间,或者堆。程序可以用堆,存储动态分配(程序运行时分配)的对象(它的创建和销毁由程序代码

YRC的博客 453

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

C++Primer笔记一-动态内存

CHAPTER12-动态内存 (C++ Primer笔记)12.1 动态内存与智能指针12.1 shared_ptr类功能快捷键合理的创建标题,有助于目录的生成如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 内存管理: **静态内存:**保存局部static对象、类static数据成员以及定义在任何函数

qq_41031090的博客 400

c++primer 第十二章 动态内存

目录 12.1 动态内存与智能指针 12.1.1 shared_ptr类 12.1.2 直接管理动态内存 12.1.3 shared_ptr和new结合使用 12.1.4 智能指针和异常 12.1.5 unique_ptr 12.1.6 weak_ptr 12.2 动态数组 12.2.1 new和数组 12.2.2 allocator类 12.1 动态内存与智能指针 c++中,通过new运算符和delete来管理动态内存,新标准中提供了两种智能指针,智能指针与普.....

weixin_42375706的博客 352

《c++primer》笔记:动态内存

C++ 动态内存

weixin_46266058的博客 2911

《c++ primer笔记》第十二章 动态内存

目前写的程序都只使用过静态内存和栈内存。==静态内存==用来保存局部`static`对象、类static数据成员以及定义在任何函数之外的变量。==栈内存==用来保存定义在函数内的非`static`对象。==分配在静态或栈内存中的对象由编译器自动创建和销毁,对于栈对象,仅在其定义的程序块运行时才存在:static对象在使用之前分配,在程序结束时销毁

qq_18824403的博客 323

c++ primer 动态内存与智能指针

share_ptr类 make_share函数:

超级大洋葱的博客 261

《c++ primer》 第12章 动态内存 学习笔记

第 12 章 动态内存 概述.动态内存和智能指针 在c++中,动态内存的管理是通过一对运算符来完成的: new,在动态内存中为对象分配空间并返回一个指向该对象的指针。我们可以选择对对象进行初始化 delete,接受一个动态对象的指针,销毁该对象,并释放与之相关的内存。 动态分配内存带来了许多问题,比如忘记释放的内存泄漏,提前释放的指针非法访问内存。 c++11新标准库提供了两种

IT小小鸟~~ 4487

C++ Primer 动态内存

动态内存动态内存与智能指针shared_ptr类动态数组 动态内存与智能指针 静态内存用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量 栈内存用来保存定义在函数内的非static对象 除了静态内存和栈内存,程序还有一个内存池称为自由空间或者堆(heap),用来存储动态分配的对象,这些对象的生存期由程序控制,必须显式地销毁 在C++中,管理动态内存使用一对运算符:n...

qq_41423750的博客 309

C++ primer 12章 动态内存

这一章,由于本身对C语言动态分配以及指针比较熟悉,所以看起来会很轻松的。 自动分配,static分配,以及动态分配对象,动态分配对象的生存期和在哪来创建无关,只有被显式地被释放,对象才销毁,不占用对应的内存空间。静态内存保存局部static对象,类static数据成员,以及定义在任何函数之外的变量。栈用来保存函数内的非static对象,静态内存和栈由编译器管理。每个程序还有堆,则由程序员管理。 运算

一个菜鸟的博客 617

C++ Primer 5th学习笔记11 动态内存

动态内存 1 动态内存和智能指针   在C++中,动态内存的管理是通过一对运算符来完成的:new,在动态内存中为对象分配空间并返回一个指向该对象的指针。delete则是接受一个动态对象的指针,销毁该对象,并释放与之相关联的内存。   动态内存的使用很容易出问题。若忘记释放内存,则会产生内存泄露;若在尚有指针引用内存的情况下就释放内存,则会产生引用非法内存的指针。   因此新标准库提供了两种智能指...

会飞的鱼的博客 367

C++Primer:第十二章 动态内存 笔记

概述信息1、静态内存用来保存1)局部static对象、2)类static数据成员、3)定义在函数外的变量。2、栈内存保存1)函数内非static对象3、静态内存和栈内存中的对象由编译器自动创建和销毁。1)栈对象:仅在其定义的程序块运行时才存在2)static对象:使用之前分配,程序结束时销毁4、补充一下C++的内存区域1)代码区:存放程序代码2)静态数据区:存放全局变量或对象、static局部变量...

人在旅途的博客 661
上一篇: 《C++ Primer》导学系列:第 11 章 - 关联容器
下一篇: 《C++ Primer》导学系列:第 13 章 - 拷贝控制
AI与编程之窗
博客等级 码龄3年 1万+粉丝 105原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AI与编程之窗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值