AI算法C++学习笔记--高级C++特性

已于 2024-05-20 12:51:03 修改
阅读量838 收藏 22
点赞数 29
分类专栏： AI算法-C++学习笔记 文章标签： 算法 c++ 学习
于 2024-05-20 09:47:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linyizhoumx/article/details/139042074
版权

高级C++特性

  • STL（标准模板库）：熟练使用STL中的容器（如vector、list、map等）、迭代器、算法和函数对象。

  • 异常处理：了解如何使用异常处理机制来提高程序的健壮性。

  • 智能指针：掌握智能指针（如unique_ptr、shared_ptr、weak_ptr）的使用，以避免内存泄漏和提高资源管理的安全性。

  • 多线程编程：理解并能够使用C++11及以后版本中的多线程库，如std::thread、std::mutex、std::future等。

STL（标准模板库）

C++标准模板库（STL）提供了一系列的容器、迭代器、算法和函数对象，它们是构建高效、可重用代码的基础组件。下面是这些组件的基本使用方法：

容器（Containers）

容器是用来存储数据的数据结构。STL提供了多种容器，包括序列容器（如vector、list、deque）和关联容器（如set、map、unordered_set、unordered_map）。

vector
vector是一个动态数组，支持随机访问。

#include <vector>

int main() {
    std::vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);

    for (size_t i = 0; i < v.size(); ++i) {
        std::cout << v[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

list
list是一个双向链表，不支持随机访问，但插入和删除操作很快。

#include <list>

int main() {
    std::list<int> l;
    l.push_back(1);
    l.push_front(2);
    l.push_back(3);

    for (auto it = l.begin(); it != l.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

map
map是一个关联容器，它存储键值对，并根据键自动排序。

#include <map>

int main() {
    std::map<std::string, int> m;
    m["one"] = 1;
    m["two"] = 2;
    m["three"] = 3;

    for (auto it = m.begin(); it != m.end(); ++it) {
        std::cout << it->first << ": " << it->second << std::endl;
    }

    return 0;
}

迭代器（Iterators）

迭代器是用于遍历容器中元素的对象。它们提供了一种统一的方式来访问容器中的元素，而不需要了解容器的内部实现。

#include <vector>

int main() {
    std::vector<int> v = {1, 2, 3};
    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

算法（Algorithms）

STL提供了大量的算法，这些算法可以作用于各种容器。它们通常通过迭代器来访问容器中的元素。

#include <vector>
#include <algorithm>

int main() {
    std::vector<int> v = {3, 1, 2};
    std::sort(v.begin(), v.end());

    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

函数对象（Function Objects）

函数对象（也称为仿函数）是重载了函数调用运算符()的对象。它们可以像函数一样被调用，并且可以存储状态。

#include <vector>
#include <algorithm>

struct Compare {
    bool operator()(int a, int b) const {
        return a < b;
    }
};

int main() {
    std::vector<int> v = {3, 1, 2};
    std::sort(v.begin(), v.end(), Compare());

    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个例子中，Compare是一个函数对象，它定义了一个比较操作，用于std::sort算法。

总结
STL的容器、迭代器、算法和函数对象是C++泛型编程的核心组件。它们提供了一种高效、可重用的方式来处理数据，使得程序员可以专注于算法的设计，而不需要重复实现基本的数据结构和操作。通过合理地使用STL，可以显著提高代码的质量和开发效率。

异常处理

在C++中，异常处理机制是一种用于处理程序运行时错误的强大工具，它可以帮助提高程序的健壮性。通过合理地使用异常处理，可以确保程序在遇到不可预见的错误时能够优雅地处理，而不是直接崩溃。以下是C++中异常处理的基本概念和使用方法：

基本概念

异常（Exception）：程序运行时出现的错误或异常情况。

抛出异常（Throwing an Exception）：当检测到异常情况时，使用throw关键字抛出一个异常对象。

捕获异常（Catching an Exception）：使用try和catch块来捕获并处理异常。

异常类（Exception Classes）：可以自定义异常类，也可以使用标准异常类。

基本语法

try {
    // 可能抛出异常的代码
} catch (exceptionType1& e) {
    // 处理 exceptionType1 类型的异常
} catch (exceptionType2& e) {
    // 处理 exceptionType2 类型的异常
} catch (...) {
    // 处理所有其他类型的异常
}

示例

#include <iostream>
#include <exception>

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "Something bad happened!";
    }
};

void mayCauseException() {
    throw MyException(); // 抛出自定义异常
}

int main() {
    try {
        mayCauseException();
    } catch (const MyException& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Caught standard exception: " << e.what() << std::endl;
    } catch (...) {
        std::cerr << "Caught unknown exception" << std::endl;
    }
    return 0;
}

提高程序健壮性的建议

  • 合理设计异常类：根据程序可能出现的错误类型，设计合适的异常类层次结构。

  • 及时清理资源：在try块中分配的资源，在catch块中应该被正确释放，可以使用RAII（Resource Acquisition Is Initialization）技术。

  • 避免过度使用异常：异常应该用于处理真正的异常情况，而不是作为常规流程控制的一部分。

  • 使用标准异常类：尽可能使用C++标准库提供的异常类，如std::exception、std::runtime_error等。

  • 异常安全：确保异常抛出时，程序的状态是安全的，不会导致资源泄露或数据损坏。

通过上述方法，可以有效地利用C++的异常处理机制来提高程序的健壮性和可靠性。

智能指针

在C++中，智能指针是一种用于自动管理动态分配内存的工具，它们可以帮助避免内存泄漏并提高资源管理的安全性。C++11引入了三种主要的智能指针：unique_ptr、shared_ptr和weak_ptr。

unique_ptr

unique_ptr是一个独占所有权的智能指针，它确保同一时间只有一个unique_ptr指向一个对象。当unique_ptr离开作用域或被重新赋值时，它所指向的对象会被自动删除。

#include <iostream>
#include <memory>

int main() {
    // 创建一个 unique_ptr
    std::unique_ptr<int> uptr(new int(42));
    // 不能直接复制 unique_ptr
    // std::unique_ptr<int> uptr2 = uptr; // 错误

    // 可以通过移动语义转移所有权
    std::unique_ptr<int> uptr2 = std::move(uptr);
    if (!uptr) {
        std::cout << "uptr is empty" << std::endl;
    }
    std::cout << "uptr2 points to " << *uptr2 << std::endl;

    return 0;
}

shared_ptr

shared_ptr是一个共享所有权的智能指针，它允许多个shared_ptr指向同一个对象。对象的生命周期由引用计数管理，当最后一个指向对象的shared_ptr被销毁时，对象会被删除。

#include <iostream>
#include <memory>

int main() {
    // 创建一个 shared_ptr
    std::shared_ptr<int> sptr1(new int(42));
    std::cout << "sptr1 use count: " << sptr1.use_count() << std::endl; // 输出 1

    {
        std::shared_ptr<int> sptr2 = sptr1;
        std::cout << "sptr2 use count: " << sptr2.use_count() << std::endl; // 输出 2
    }

    std::cout << "sptr1 use count after sptr2 goes out of scope: " << sptr1.use_count() << std::endl; // 输出 1

    return 0;
}

weak_ptr

weak_ptr是一个弱引用智能指针，它通常与shared_ptr一起使用，用于解决循环引用的问题。weak_ptr不控制对象的生命周期，它只是观察shared_ptr所指向的对象。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sptr(new int(42));
    std::weak_ptr<int> wptr(sptr);

    if (auto ptr = wptr.lock()) {
        std::cout << "Object is still alive, value: " << *ptr << std::endl;
    } else {
        std::cout << "Object is dead" << std::endl;
    }

    sptr.reset();

    if (auto ptr = wptr.lock()) {
        std::cout << "Object is still alive, value: " << *ptr << std::endl;
    } else {
        std::cout << "Object is dead" << std::endl;
    }

    return 0;
}

总结
智能指针是C++中管理动态内存的有效工具，它们可以自动处理内存的分配和释放，从而避免内存泄漏。unique_ptr适用于独占资源的情况，shared_ptr适用于共享资源的情况，而weak_ptr则用于解决shared_ptr可能导致的循环引用问题。合理使用这些智能指针可以显著提高C++程序的健壮性和安全性。

多线程编程

C++11引入了标准的多线程库，使得在C++中进行并发编程变得更加容易和安全。这个库包括了线程管理、互斥量、条件变量、原子操作和异步操作等功能。下面是一些主要组件的使用介绍：

std::thread

std::thread用于创建和管理线程。你可以通过它来启动一个新的线程，并执行一个函数。

#include <iostream>
#include <thread>

void threadFunction() {
    std::cout << "Hello from a thread!" << std::endl;
}

int main() {
    std::thread t(threadFunction);
    t.join(); // 等待线程结束
    return 0;
}

std::mutex

std::mutex是互斥量，用于保护共享资源，防止多个线程同时访问。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void threadFunction() {
    mtx.lock();
    std::cout << "Hello from a thread!" << std::endl;
    mtx.unlock();
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    return 0;
}

std::lock_guard 和 std::unique_lock

std::lock_guard和std::unique_lock是互斥量的RAII风格的包装，它们在构造时自动锁定互斥量，在析构时自动解锁，确保了互斥量的正确管理。

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void threadFunction() {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Hello from a thread!" << std::endl;
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    return 0;
}

std::future 和 std::promise

std::future和std::promise用于在线程之间传递结果。std::promise用于设置值，而std::future用于获取这个值。

#include <iostream>
#include <thread>
#include <future>

void setPromise(std::promise<int>&& prom) {
    prom.set_value(42);
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    std::thread t(setPromise, std::move(prom));
    std::cout << "Result: " << fut.get() << std::endl;
    t.join();
    return 0;
}

std::async

std::async是一个便捷的函数，它启动一个异步任务，并返回一个std::future对象，你可以通过这个对象获取任务的结果。

#include <iostream>
#include <future>

int compute() {
    return 42;
}

int main() {
    std::future<int> fut = std::async(compute);
    std::cout << "Result: " << fut.get() << std::endl;
    return 0;
}

C++11及以后版本的多线程库提供了丰富的并发编程工具，包括线程管理、同步原语和异步操作等。合理使用这些工具可以编写出高效且安全的并发程序。在编写多线程代码时，应该注意避免数据竞争和死锁，确保线程间的同步和通信是正确和高效的。

Ryan_BME
关注
  • 29
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
信息奥赛c++学习笔记——贪心算法
01-06
一，算法 在当前状态下找出局部最优解，转化为全局最优解。 二，活动安排问题 1.问题描述：给定n个开区间（ai，bi），在给定范围内尽量选择多个区间，使得这些区间两两没有公共点。 2.算法：按照结束时间bi从小到大...
C++开发、机器学习、深度学习、推荐算法基础知识及面试题总结.zip
06-13
其次，机器学习是人工智能的一个分支，主要研究如何让计算机从数据中学习。其核心知识点包括： 1. 监督学习与非监督学习：理解分类、回归、聚类等任务的区别。 2. 常见模型：线性回归、逻辑回归、SVM、决策树、随机...
AI算法C++学习笔记--性能优化
linyizhoumx的博客
05-20 576
在某些情况下，标准库中的数据结构和算法可能无法满足特定需求。这时，你可能需要自定义数据结构和算法。例如，设计一个自定义的哈希表来处理特定的键类型，或者实现一个自定义的排序算法来处理特殊的数据分布。
蓝桥杯 字符串编码
qq_52253798的博客
12-12 256
题目描述： 小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →26。这样一个字符串就能被转化成一个数字序列：比如 ABCXYZ → 123242526。现在给定一个转换后的数字序列，小明想还原出原本的字符串。当然这样的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字 符串。 【输入格式】 一个数字序列。 【输出格式】 一个只包含大写字母的字符串，代表答案 【样例输入】 1232425
C++ AI
风之双子天谴
02-12 680
虽然Python是深度学习框架（如TensorFlow和PyTorch）的首选语言，但也有一些C++实现的深度学习框架，如Tiny-DNN和DeepLearning4j的C++后端。此外，对于更复杂的机器学习模型，通常会使用专门的机器学习库，如MLPack、Shogun或TensorFlow的C++ API，这些库提供了丰富的算法和工具来构建和训练模型。：许多机器学习库，如TensorFlow的C++ API、MLPack、Shogun等，都是用C++编写的。最后，它输出了这些参数。
AI算法C++学习笔记--AI领域涉及的C++库
linyizhoumx的博客
05-20 907
TensorFlow和PyTorch的C++ API，以及Dlib和mlpack等专门的C++机器学习库，为C++开发者提供了强大的工具来构建和部署机器学习模型。这些库通常用于需要高性能计算的场景，或者与现有的C++代码库集成。选择合适的库取决于项目的需求、库的性能、易用性以及社区支持。通过使用这些库，开发者可以有效地在C++环境中实现复杂的机器学习任务。OpenCV、Dlib、VIGRA和ITK等计算机视觉库提供了丰富的C++接口，使得开发者能够高效地实现图像处理和计算机视觉任务。
DE.zip_数值算法/人工智能_C/C++_
08-11
DE.zip 文件包含的是关于数值算法和人工智能在C/C++编程语言中的应用资料，特别是DE.txt这个文本文件，很可能记录了作者对于这些领域的理解和实践总结。数值算法是解决数学问题和科学计算的重要工具，而人工智能则...
Python-20182019校招春招秋招算法NLP深度学习机器学习面试笔记
08-10
《Python-20182019校招春招秋招算法NLP深度学习机器学习面试笔记》 本资料集主要针对2018年至2019年期间的校园招聘，特别是春季和秋季招聘，面向那些对自然语言处理（NLP）、深度学习（Deep Learning）以及机器学习...
Awesome-AI-algorithm:人工智能算法方面的综合资料合集
05-09
人工智能算法方面的综合资料合集:包括求职面试、机器学习、深度学习、强化学习等方面的资料和代码（持续更新中） 近期将更新一大波互联网大厂实习内推、校招相关信息（敬请关注！） 资料目录 大厂内推：实习/春招/...
函数模板与类模板
程序员_小兵
07-12 1296
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 870
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 307
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
最新发布
hanmo22357的博客
07-12 483
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 134
【代码】代码随想录算法训练营第33天。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
weixin_46281930的博客
07-09 462
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
C语言力扣刷题12——合并区间[排序]
why1249777255的博客
07-09 426
C语言，合并区间，二维数组的快速排序，qsort，中等难度。
【代码随想录】【算法训练营】【第62天】 [卡码108]冗余连接 [卡码109]冗余连接II
weixin_54954007的博客
07-08 581
思路及算法思维，指路。题目来自。day 62，又是一个周一，ding~
人工智能-深度学习-深度学习算法在软测量建模中的应用研究.pdf
06-27
人工智能-深度学习-深度学习算法在软测量建模中的应用研究.pdf

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值