读书笔记：《Effective Modern C++（C++14）》

Effective Modern C++（C++14）

GitHub - CnTransGroup/EffectiveModernCppChinese: 《Effective Modern C++》- 完成翻译

Deducing Types

  1. 模版类型推导：
    1. 引用，const，volatile被忽略
    2. 数组名和函数名退化为指针
    3. 通用引用：
      1. 左值保持引用和const
      2. 右值忽略引用和const
  2. auto 类型推导：
    1. {} 初始化被auto推导为std::initializer_list
    2. 模版推导无法解析 {} 初始化
    3. 不可见的代理类可能会使auto从表达式中推导出“错误的”类型
  3. decltype 类型推导：
    1. 将decltype应用于变量名会产生该变量名的声明类型
    2. 返回decltype-》auto + decltype尾返回类型
    3. auto 与 decltype(auto)不同，decltype保留了auto忽略的左值引用
decltype(x+y) add(T x, U y){}; // 编译错误

template <typename T, typename U>
auto add(T x, U y) -> decltype(x+y) 
{ 
    return x+y; 
} 

template <typename T, typename U> // C++ 14
auto add(T x, U y) 
{ 
    return x+y; 
}

decltype(auto) f1()
{
    int x = 0;
    return x;                            //decltype(x）是int，所以f1返回int
}

decltype(auto) f2()
{
    int x = 0;
    return (x);                          //decltype((x))是int&，所以f2返回int&
}
  1. 查看类型推导结果：
    1. 编译期：编译期报错诊断
    2. 运行时：
      1. typeid：依赖编译期解析，可能不正确
      2. Boost.TypeIndex
template<typename T>                //只对TD进行声明
class TD;                           //TD == "Type Displayer"
// 如果尝试实例化这个类模板就会引出一个错误消息，因为这里没有用来实例化的类模板定义。为了查看x和y的类型，只需要使用它们的类型去实例化TD：
TD<decltype(x)> xType;              //引出包含x和y
TD<decltype(y)> yType;              //的类型的错误消息


template<typename T>
void f(const T& param)
{
    using std::cout;
    cout << "T =     " << typeid(T).name() << '\n';             //显示T
    cout << "param = " << typeid(param).name() << '\n';         //显示
}                                                               //的类型


#include <boost/type_index.hpp>

template<typename T>
void f(const T& param)
{
    using std::cout;
    using boost::typeindex::type_id_with_cvr;
    //显示T
    cout << "T =     "
         << type_id_with_cvr<T>().pretty_name()
         << '\n';    
    //显示param类型
    cout << "param = "
         << type_id_with_cvr<decltype(param)>().pretty_name()
         << '\n';
}

Modern C++：98 vs 11

  1. 构造，拷贝构造，拷贝复制
Widget w1;              //调用默认构造函数
Widget w2 = w1;         //不是赋值运算，调用拷贝构造函数
w1 = w2;                //是赋值运算，调用拷贝赋值运算符（copy operator=）
  1. 初始化：（），=，{}
    1. （）：构造，无参构造和函数声明语义冲突，无参构造应该省略（）
    2. =：拷贝构造，拷贝赋值
    3. {}：统一初始化，不允许类型变窄
  2. std::initializer_list 和 {} 初始化永远是最佳匹配
  3. () 初始化和 {} 初始化可能会有巨大不同：ex：std::vector
  4. 重载指针参数和整型参数：
    1. 0：int
    2. NULL：int or long
    3. nullptr：std::nullptr_t，可以隐式转换为指向任何内置类型的指针
  5. **typedef（C++98）和using（C++11）：**using别名模版更简单，不需要::type和typename
template<typename T>                            //MyAllocList<T>是
using MyAllocList = std::list<T, MyAlloc<T>>;   //std::list<T, MyAlloc<T>>
MyAllocList<Widget> lw;                         //用户代码

template<typename T>                            //MyAllocList<T>是
struct MyAllocList {                            //std::list<T, MyAlloc<T>>
    typedef std::list<T, MyAlloc<T>> type;      //的同义词  
};
MyAllocList<Widget>::type lw;                   //用户代码

template<typename T>
class Widget {                              //Widget<T>含有一个
private:                                    //MyAllocLIst<T>对象
    typename MyAllocList<T>::type list;     //作为数据成员
}; 

template <class T> 
using remove_const_t = typename remove_const<T>::type;
template <class T> 
using remove_reference_t = typename remove_reference<T>::type;
template <class T> 
using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
  1. 非限域Enum（C+98）和限域Enum（C++11）：限域class enum不污染命名空间，都支持底层类型，但是Enum class不能隐式转换只能cast
enum Color { black, white, red };   //black, white, red在Color所在的作用域
auto white = false;                 //错误! white早已在这个作用域中声明


enum class Color { black, white, red }; //black, white, red限制在Color域内
auto white = false;                     //没问题，域内没有其他“white”
Color c = white;                        //错误，域中没有枚举名叫white
Color c = Color::white;                 //没问题

using UserInfo =                //类型别名，参见Item9
    std::tuple<std::string,     //名字
               std::string,     //email地址
               std::size_t> ;   //声望

enum UserInfoFields { uiName, uiEmail, uiReputation };
UserInfo uInfo;                         //同之前一样
auto val = std::get<uiEmail>(uInfo);    //啊，获取用户email字段的值

template<typename E>                //C++14
constexpr std::underlying_type_t<E>
    toUType(E enumerator) noexcept
{
    return static_cast<std::underlying_type_t<E>>(enumerator);
}
auto val = std::get<toUType(UserInfoFields::uiEmail)>(uInfo);
  1. 未定义私有声明（C++98）和deleted（C++11）：
    1. 删除自动生成的函数：都可
    2. 删除隐式转换类型的函数重载：only deleted
template <class charT, class traits = char_traits<charT> >
class basic_ios : public ios_base {
private:
    basic_ios(const basic_ios& );           // not defined
    basic_ios& operator=(const basic_ios&); // not defined
};


template <class charT, class traits = char_traits<charT> >
class basic_ios : public ios_base {
public:
    basic_ios(const basic_ios& ) = delete;
    basic_ios& operator=(const basic_ios&) = delete;
};


bool isLucky(int number);       //原始版本
bool isLucky(char) = delete;    //拒绝char
bool isLucky(bool) = delete;    //拒绝bool
bool isLucky(double) = delete;  //拒绝float和double

template<>
void processPointer<void>(void*) = delete;
template<>
void processPointer<char>(char*) = delete;
class Widget {
public:
    template<typename T>
    void processPointer(T* ptr)
};
template<>                                          //还是public，
void Widget::processPointer<void>(void*) = delete;  //但是已经被删除了
  1. 显式override和final来实现重载和避免重载：C++11新增引用限定符
class Widget {
public:
    using DataType = std::vector<double>;
    DataType& data() &              //对于左值Widgets,
    { return values; }              //返回左值
    DataType data() &&              //对于右值Widgets,
    { return std::move(values); }   //返回右值
private:
    DataType values;
};
  1. 优先使用const_iterator而非iterator
  2. **begin，end，cbegin，rbegin的非成员函数通用性更强，**可用于原生数组
  3. **尽可能使用noexcept：**可以编译优化，noexcept函数可以调用异常中立函数
RetType function(params) noexcept;  //极尽所能优化	//C++11风格，没有来自f的异常
RetType function(params) throw();   //较少优化		//C++98风格，没有来自f的异常
RetType function(params);           //较少优化
  1. **const 常量，编译期不一定可知；constexpr 编译期常量，编译期可知；constexpr 函数值根据参数在编译期是否可知决定，**constexpr函数既可以是运行时也可以是编译期
  2. const成员函数中的mutable成员变量，需要mutex或atomic来保证线程安全
  3. 特殊成员函数：构造，析构，拷贝构造，拷贝赋值，移动构造，移动赋值
  4. **Role of Three：**自定义资源管理时，析构，拷贝构造，拷贝赋值同时自定义
  5. 移动操作仅当类没有显式声明移动操作，拷贝操作，析构函数时才自动生成
  6. 在自定义移动时，相应拷贝被deleted，在自定义析构时，拷贝不自动生成
  7. **置入emplace_back优于插入push_back：**避免了临时对象的创建和销毁

Smart Pointers

  • **unique_ptr：专有所有权，大小与原始指针相同，不占用额外内存资源，**完全拥有指向内容的所有权，只能移动不能复制，可以转化为shared_ptr
  • **shared_ptr：共享所有权，大小是原始指针二倍，包含引用计数，**引用计数在堆上，内存动态分配，原子操作增减
    • 使用maked_shared创建，或直接传递new指针，不要传递原始指针变量
    • 如果原始指针变量存在，且存在多个基于原始指针的shared_ptr，会存在多次析构的问题
  • **weak_ptr：从shared_ptr创建，不拥有所有权，**只能判断原指针是否过期，不能解引用
    • 获取shared_ptr：lock()，shared_ptr()
    • 避免shared_ptr循环引用无法释放
    • 作为缓存，观察者，只判断是否过期
  • make_shared, make_unique：
    • 异常安全，异常时不会导致内存泄漏
    • 对象内存和引用计数内存一次分配
    • 控制块和对象内存块绑定，存在weak_ptr时无法实际释放内存

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • Pimpl，Pointer to implementation：通过减少在类实现和类使用者之间的编译依赖来减少编译时间。（减少头文件中包含其他头文件的数量）
    • unique_ptr: 独占所有权，符合抽象，析构函数和移动拷贝函数的定义需要在不完整类型实现之后
    • shared_ptr：共享所有权，不符合抽象，运行时数据结构更大
// 原 header
class Widget() {                    //定义在头文件“widget.h”
public:
    Widget();
    …
private:
    std::string name;
    std::vector<double> data;
    Gadget g1, g2, g3;              //Gadget是用户自定义的类型
};

// 新 header
class Widget {                          //仍然在“widget.h”中
public:
    Widget();
    ~Widget();

    Widget(Widget&& rhs);               //只有声明
    Widget& operator=(Widget&& rhs);
    …

private:                                //跟之前一样
    struct Impl;
    std::unique_ptr<Impl> pImpl;
};

// 新 cpp
#include <string>                   //跟之前一样，仍然在“widget.cpp”中
…
    
struct Widget::Impl { … };          //跟之前一样

Widget::Widget()                    //跟之前一样
: pImpl(std::make_unique<Impl>())
{}

Widget::~Widget() = default;        //跟之前一样

Widget::Widget(Widget&& rhs) = default;             //这里定义
Widget& Widget::operator=(Widget&& rhs) = default;

Rvalue, Move & Forward

  • **move：**无条件将实参转化为右值，不一定移动构造，const变量无法移动时只能拷贝构造
  • **forward：**当且仅当实参为右值时，将其转化为右值
  • move 和 forward 都是** cast 操作，运行期无代码**
  • **通用引用：**T&&, auto&&，类型推导决定是左值引用还是右值引用
  • 函数返回值，传参，最后一次使用：右值引用使用move，通用引用使用forward
  • **返回值优化：**返回函数内的局部对象
    • 使用move移动操作来返回
    • 直接在返回值的内存中构建局部对象，消除拷贝操作
  • 通用引用参数的函数重载，优先级高于大部分函数
  • 完美转发的构造函数，non-const的优先级可能会大于拷贝构造和系统构造函数
  • 重载通用引用：
    • tag dispatch
template<typename T>
void logAndAdd(T&& name)
{
    logAndAddImpl(
        std::forward<T>(name),
        std::is_integral<typename std::remove_reference<T>::type>()
    );
}

template<typename T>                            //非整型实参：添加到全局数据结构中
void logAndAddImpl(T&& name, std::false_type)	//译者注：高亮std::false_type
{
    auto now = std::chrono::system_clock::now();
    log(now, "logAndAdd");
    names.emplace(std::forward<T>(name));
}

std::string nameFromIdx(int idx);           //与条款26一样，整型实参：查找名字并用它调用logAndAdd
void logAndAddImpl(int idx, std::true_type) //译者注：高亮std::true_type
{
  logAndAdd(nameFromIdx(idx)); 
}
  • enable_if 约束
class Person  {                                         //C++14
public:
    template<
        typename T,
        typename = std::enable_if_t<                    //这儿更少的代码
                       !std::is_base_of<Person,
                                        std::decay_t<T> //还有这儿
                                       >::value
                   >                                    //还有这儿
    >
    explicit Person(T&& n);
    …
};
  • 引用折叠（reference collapsing）。禁止你声明引用的引用，但是编译器会在特定的上下文中产生这些。当编译器生成引用的引用时，引用折叠指导下一步发生什么。
    • 如果任一引用为左值引用，则结果为左值引用。否则（即，如果引用都是右值引用），结果为右值引用。
    • 折叠发生在四种情况下：模板实例化，auto类型推导，typedef与别名声明的创建和使用，decltype。
    • 通用引用就是在特定上下文的右值引用，上下文是通过类型推导区分左值还是右值，并且发生引用折叠的那些地方。
  • **移动语义的缺陷：**某些情况不存在，速度不如复制，非noexcept移动不可用
  • 完美转发（perfect forwarding）意味着我们不仅转发对象，我们还转发显著的特征：它们的类型，是左值还是右值，是const还是volatile。
  • **完美转发失败：**花括号初始化，作为空指针的0或者NULL，仅有声明的整型static const数据成员，模板和重载函数的名字，位域。
template<typename T>
void fwd(T&& param)             //接受任何实参
{
    f(std::forward<T>(param));  //转发给f
}

template<typename... Ts>
void fwd(Ts&&... params)            //接受任何实参
{
    f(std::forward<Ts>(params)...); //转发给f
}
  • 重载拷贝左值，移动右值-》完美转发-》直接传值移动：
    • 多一次额外的移动，适用移动开销低
      • 左值：拷贝+移动
      • 右值：移动+移动
    • 实现简单，不用重载，不用模版
class Widget {                                  //方法1：对左值和右值重载
public:
    void addName(const std::string& newName)
    { names.push_back(newName); } // rvalues
    void addName(std::string&& newName)
    { names.push_back(std::move(newName)); }
private:
    std::vector<std::string> names;
};

class Widget {                                  //方法2：使用通用引用
public:
    template<typename T>
    void addName(T&& newName)
    { names.push_back(std::forward<T>(newName)); }
};

class Widget {                                  //方法3：传值
public:
    void addName(std::string newName)
    { names.push_back(std::move(newName)); }
};

Lambda

lambdas 和闭包类存在于编译期，闭包存在于运行时。

  • **按引用捕获：**捕获的变量超出生命周期，导致悬空引用
  • **按值捕获【默认】：**捕获指针，导致悬空引用；无法捕捉成员变量，只能捕捉this指针；无法捕捉static变量
  • **初始化捕获，可以捕获移动对象【移动捕获】：**c++11可以使用bind来模拟捕获移动对象
auto func = [pw = std::move(pw)]        //使用std::move(pw)初始化闭包数据成员
            { return pw->isValidated()
                     && pw->isArchived(); };

auto func = [pw = std::make_unique<Widget>()]   //使用调用make_unique得到的结果
            { return pw->isValidated()          //初始化闭包数据成员
                     && pw->isArchived(); };
  • **泛型捕获：**捕获auto&&，C++11可以使用bind的完美转发来模拟泛型捕获
auto f = [](auto&& param){return func(std::forward<decltype(param)>(param));};

auto f = [](auto&&... param){return func(std::forward<decltype(param)>(param)...);};
  • 使用lambda取代bind：
// lambda
auto setSoundL = [](Sound s) {
        using namespace std::chrono;
        using namespace std::literals;      //对于C++14后缀

        setAlarm(steady_clock::now() + 1h,	//C++14写法，但是含义同上
                 s,
                 30s);
    };

// bind
using SetAlarm3ParamType = void(*)(Time t, Sound s, Duration d);

auto setSoundB = std::bind(
	static_cast<SetAlarm3ParamType>(setAlarm), // 无法处理类型重载，需要显式制定类型
    std::bind(std::plus<>(), steady_clock::now(), 1h), // 需要推迟表达式求值，避免在调用实际函数前求值
    _1,
	30s);

Concurrency API

Concurrency support library (since C++11) - cppreference.com

concurrency library

  • ：Mutual exclusion
    • lock_guard，unique_lock
  • <condition_variable>

atomic & mutex

  • **atomic：**原子操作，一个CPU指令实现
  • **mutex：**互斥锁，可由atomic实现加锁解锁操作，未拿到锁需要陷入内核完成线程挂起
  • **自旋锁：**可由atomic实现，未拿到锁不会挂起线程，效率高于互斥锁

atomic & volatile

  • std::atomic用在并发编程中，对访问特殊内存没用。
    • 可以限制编译器或底层硬件对代码进行重排和乱序执行，在不使用互斥锁时，避免并发编程时的数据竞争问题
  • volatile用于访问特殊内存，对并发编程没用。
    • 内存映射IO时，编译器不会优化重复读写，冗余访问，无用存储等代码

thread, pthread & cpu cores

  • 硬件线程：
    • 物理CPU个数：个人电脑1个插槽，服务器2个插槽
    • 物理CPU核心数【物理CPU的芯片组数量】：双核，四核，八核
    • 逻辑核=虚拟核=硬件线程【超线程，同步多线程技术】：8核16线程
  • 软件线程：
    • 系统线程，操作系统线程，操作系统调度到硬件线程上执行的线程
    • pthread（POSIX thread），windows thread
  • std::thread：
    • C++对象，软件线程的句柄
    • joinable：正在运行
    • unjoinable：
      • 默认构造
      • 已被移动
      • join：运行完毕
      • detach：与软件线程之间的连接关系被打断

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

thread & future

  • 基于线程异步执行：std::thread t(doAsyncWork);
    • 不能直接访问异步执行的结果，如果执行函数有异常抛出，代码会终止执行。
    • 自己处理线程耗尽、资源超额、负载均衡、平台适配等问题
    • 可以访问pthread api，使用thread pool
  • 基于任务异步执行：auto fut = std::async(doAsyncWork);
    • 可以获取异步执行的结果和异常
    • 标准库处理线程耗尽、资源超额、负载均衡、平台适配等问题
    • 默认std::launch::async | std::launch::deferred, 不保证执行，异步执行， std::launch::async强制异步执行

thread disconstruction

析构joinable的thread会导致程序终止。

使用RAII（“Resource Acquisition Is Initialization，资源获得即初始化）包装thread，在析构时进行join。

class ThreadRAII {
public:
    enum class DtorAction { join, detach };
    
    ThreadRAII(std::thread&& t, DtorAction a)
    : action(a), t(std::move(t)) {}

    ~ThreadRAII()
    {
        if (t.joinable()) {
            if (action == DtorAction::join) {
                t.join();
            } else {
                t.detach();
            }
        }
    }

    std::thread& get() { return t; }

private:
    DtorAction action;
    std::thread t;
};

future disconstruction

image.png
析构future会导致隐式的join或隐式的detach：

  • 引用了强制异步任务的共享状态的最后一个future，隐式join，在异步执行完成之前阻塞
  • 其他future，隐式detach

thread communication: condition variable，atomic & future

  1. **condition variable + mutex：**需要结合互斥锁，且需要重复验证避免虚假唤醒
std::condition_variable cv;         //事件的条件变量
std::mutex m;                       //配合cv使用的mutex
…                                   //检测事件
cv.notify_one();                    //通知反应任务
…                                       //反应的准备工作
{                                       //开启关键部分

    std::unique_lock<std::mutex> lk(m); //锁住互斥锁
    cv.wait(lk);                        //释放锁后等待通知，通知后再次加锁
    …                                   //对事件进行反应（m已经上锁）
}                                       //关闭关键部分；通过lk的析构函数解锁m
…                                       //继续反应动作（m现在未上锁）
  1. **atomic：**基于轮询，而不是阻塞
std::atomic<bool> flag(false);          //共享的flag
…                                       //检测某个事件
flag = true;                            //告诉反应线程
…                                       //准备作出反应
while (!flag);                          //等待事件
…                                       //对事件作出反应
  1. **future：**使用了堆内存存储共享状态，只能使用一次通信
std::promise<void> p;                   //通信信道的promise
…                                       //检测某个事件
p.set_value();                          //通知反应任务
…                                       //准备作出反应
p.get_future().wait();                  //等待对应于p的那个future
…                                       //对事件作出反应

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/210270.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

关于安科瑞预付费系统在转供电情况下的应用-安科瑞 蒋静

关于安科瑞预付费系统在转供电情况下的应用-安科瑞 蒋静

1 前言 国家从2018年开始对转供电加价开展规范清理以来&#xff0c;已经出来了一系列政策&#xff0c;不仅包括专门针对转供电问题的政策&#xff0c;18-20年间还在每次降电价政策中突出强调了转供电主体不得截留降价红利的要求。从具体内容看&#xff0c;各地政策都鼓励一户一…
阅读更多...
rtmp 协议详解

rtmp 协议详解

1. handshake 1.1 概述 rtmp 连接从握手开始。它包含三个固定大小的块。客户端发送的三个块命名为 C0,C1,C2&#xff1b;服务端发送的三个块命名为 S0,S1,S2。 握手序列&#xff1a; 客户端通过发送 C0 和 C1 消息来启动握手过程。客户端必须接收到 S1 消息&#xff0c;然后…
阅读更多...
05-建造者模式-C语言实现

05-建造者模式-C语言实现

UML类图&#xff1a; 代码实现&#xff1a; #include <stdio.h> #include <stdlib.h>// 产品类 typedef struct {char* part1;char* part2;char* part3; } Product;// 抽象建造者类 typedef struct {void (*buildPart1)(void*, const char*);void (*buildPart2)(v…
阅读更多...
8.4 Windows驱动开发：文件微过滤驱动入门

8.4 Windows驱动开发：文件微过滤驱动入门

MiniFilter 微过滤驱动是相对于SFilter传统过滤驱动而言的&#xff0c;传统文件过滤驱动相对来说较为复杂&#xff0c;且接口不清晰并不符合快速开发的需求&#xff0c;为了解决复杂的开发问题&#xff0c;微过滤驱动就此诞生&#xff0c;微过滤驱动在编写时更简单&#xff0c;…
阅读更多...
固定Microsoft Edge浏览器的位置设置，避免自动回调至中国

固定Microsoft Edge浏览器的位置设置，避免自动回调至中国

问题描述 在使用Copilot等功能时&#xff0c;需要将Microsoft Edge浏览器的位置设置为国外。但每次重新打开浏览器后&#xff0c;位置设置又自动回调至中国&#xff0c;导致每次均需要手动调整。 原因分析 这个问题的出现是因为每次启动Microsoft Edge时&#xff0c;默认打开…
阅读更多...
VT-MRPA1-151-1X/V0/0控制2FRE16模块式模拟放大器

VT-MRPA1-151-1X/V0/0控制2FRE16模块式模拟放大器

适用于控制带有电气位置反馈的直动式比例减压阀&#xff08;DBETR- 1X 类型&#xff09;或带有电气位置反馈的比例流量控制阀&#xff08;2FRE... 类型&#xff09;&#xff1b;控制值输入 1 0 V&#xff08;差动输入&#xff09;&#xff1b; 可分别调节“上/下”斜坡时间的斜…
阅读更多...
RCE绕过

RCE绕过

1.[SCTF 2021]rceme 总结下获取disabled_funciton的方式 1.phpinfo() 2.var_dump(ini_get(“disable_functions”)); 3.var_dump(get_cfg_var(“disable_functions”)); 其他的 var_dump(get_cfg_var(“open_basedir”)); var_dump(ini_get_all()); <?php if(isset($_POS…
阅读更多...
MMdetection3.0 问题：DETR验证集上AP值全为0.0000

MMdetection3.0 问题：DETR验证集上AP值全为0.0000

MMdetection3.0 问题&#xff1a;DETR验证集上AP值全为0.0000 条件&#xff1a; 1、选择的是NWPU-VHR-10数据集&#xff0c;其中训练集455张&#xff0c;验证、测试相同均为195张。 2、在Faster-rcnn、YOLOv3模型上均能训练成功&#xff0c;但是在DETR训练时&#xff0c;出现验…
阅读更多...
分享89个节日PPT，总有一款适合您

分享89个节日PPT，总有一款适合您

分享89个节日PPT&#xff0c;总有一款适合您 89个节日PPT下载链接&#xff1a;https://pan.baidu.com/s/1j6Yj-7UCcUyV4V_S_eGjpQ?pwd6666 提取码&#xff1a;6666 Python采集代码下载链接&#xff1a;采集代码.zip - 蓝奏云 学习知识费力气&#xff0c;收集整理更不易…
阅读更多...
【计算机毕业设计】java网上服装商城销售系统springboot+jsp

【计算机毕业设计】java网上服装商城销售系统springboot+jsp

目前互联网上的网上销售系统每天以惊人的速度增加&#xff0c;网上购物越来越成为现代年轻人的首选&#xff0c;足不出门便能选购好自己称心如意的商品。基于Java术及MySQL数据库设计与实现一个网上服装销售系统&#xff0c;要求实现用户管理、服装管理、新闻公告管理、留言管理…
阅读更多...
vue项目报错及解决npm run build:prod打包错误

vue项目报错及解决npm run build:prod打包错误

vue项目报错及解决npm run build:prod打包错误 执行dev环境时加载失败了该变量&#xff0c;在package.json文件中 删掉 解决方法&#xff1a; 打包成功&#xff1a;
阅读更多...
03-抽象工厂模式-C语言实现

03-抽象工厂模式-C语言实现

说明&#xff1a; 均由 chatgpt生成&#xff0c;实例可以看出无法运行&#xff0c;仅供参考~ 抽象工厂模式&#xff1a; 代码实现&#xff1a; #include <stdio.h>// 定义抽象产品接口 typedef struct {void (*operation)(); } AbstractProductA;typedef struct {voi…
阅读更多...
linux设置权限_setfacl_getfacl

linux设置权限_setfacl_getfacl

3.2 设置权限ACL&#xff08;access control list&#xff09; 假设&#xff1a;/data所有者与所属组均为root&#xff0c;在不改变所有者的前提下&#xff0c;要求用户tom对该目录有完全访问权限&#xff08;rwx&#xff09;。只能考虑&#xff1a; 方法一&#xff1a;给/dat…
阅读更多...
Data Grip的安装和使用

Data Grip的安装和使用

安装&#xff1a; 1.1 双击 exe 文件安装 1.2选择安装目录&#xff0c;点击next 1.3选择安装目录&#xff0c;点击next 1.3 创建快捷方式&#xff0c;安装 1.4点击install 连接&#xff1a; 2.1 创建Project 2.2创建连接 下载驱动&#xff0c;可能时间会比较久一点&#xff0c…
阅读更多...
保护您的数据库免受注入攻击：MSSQL注入入门指南

保护您的数据库免受注入攻击：MSSQL注入入门指南

MSSQL注入的入门讲解 一、引言二、MSSQL注入的基础知识2.1、MSSQL数据库的基本原理和结构2.2、常见的SQL语句和操作2.3、MSSQL注入的原理和工作方式 三、MSSQL注入攻击技术3.1、基于错误的注入攻击&#xff1a;利用错误消息和异常信息3.2、基于时间的注入攻击&#xff1a;利用延…
阅读更多...
ArkUI组件--image组件

ArkUI组件--image组件

Image&#xff1a;图片显示组件 1.声明Image组件并设置图片的源&#xff1a; Image(src:string|PixelMap|Resource) #src表示源&#xff0c;支持三种格式①string格式&#xff0c;常用来加载网络图片&#xff0c;填写网址。&#xff08;手机端需要申请网络访问权限&#xff1…
阅读更多...
【JavaSE学习专栏】第03篇 数组

【JavaSE学习专栏】第03篇 数组

文章目录 1 数组的定义2 数组声明创建3 数组的初始化4 数组的四个基本特点5 数组边界6 数组的使用7 多维数组8 Arrays类9 冒泡排序9.1 原理9.2 代码实现 10 数组插入算法10.1 问题10.2 分析10.3 代码 11 稀疏矩阵11.1 稀疏数组介绍 1 数组的定义 数组是相同类型数据的有序集合。…
阅读更多...
StarRC常见问题整理

StarRC常见问题整理

我正在「拾陆楼」和朋友们讨论有趣的话题，你⼀起来吧？ 拾陆楼知识星球入口 使用starrc_cmd “错误代码”就能看对应Error或Warnning的解释。如: starrc_cmd SX-2505 1）nxtgrd版本问题 INFORMATION: TCAD_GRD_FILE (nxtgrd file) generate by > 4 years older version…
阅读更多...
Flink入门（一）

Flink入门（一）

整体框架 Flink概述Flink上手部署Flink架构DataStream API(算子)Flink中的时间和窗口&#xff1a;窗口就是范围处理函数&#xff1a;底层函数状态管理&#xff1a;容错机制&#xff1a;报错重启后能够从出错的位置继续执行FlinkSQL&#xff1a;功能逐步完善 基于数据流的有状…
阅读更多...
【一周安全资讯1202】信安标委发布《网络安全标准实践指南—网络安全产品互联互通 告警信息格式》；网络安全纳入注册会计师考试科目

【一周安全资讯1202】信安标委发布《网络安全标准实践指南—网络安全产品互联互通 告警信息格式》；网络安全纳入注册会计师考试科目

要闻速览 1、信安标委发布《网络安全标准实践指南—网络安全产品互联互通 告警信息格式》 2、南昌某高校学生个人信息在境外公开出售&#xff0c;警方抓获学校"内鬼" 3、网络安全纳入注册会计师考试科目 4、乌克兰情报机构网攻俄罗斯民航局&#xff0c;称俄民航业正…
阅读更多...
最新文章

Copyright @ 2022~2023