《Effective Modern C++》学习记录(四):右值与移动语义

已于 2025-05-11 11:01:41 修改
阅读量780 收藏 14
点赞数 17
分类专栏： 《Effective Modern C++》学习记录 文章标签： c++ 学习
于 2025-05-11 11:00:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73644079/article/details/147869964
版权

原blog：《Effective Modern C++》学习记录(四):右值与移动语义 | RecursiveThoughts

1 左值 lvalue 与右值 rvalue

1.1 区分

  • 右值对应着从函数返回的临时对象，左值对应着可以被引用reference的（通过名字、指针pointer或左值引用）。

  • 能取到地址的，是左值；不能取到地址的，是右值。

  • 拷贝右值的构造通常是移动构造，拷贝左值的构造通常是拷贝构造。

1.2 函数传参时

  • 一旦参数进入函数内部，它们就获得了具体的名称和持久的存储位置，因此所有的参数都是左值。

  • 即使传的参数是右值引用类型rvalue reference types，它本身在函数中也是一个左值。

1.3 实参arguments和形参parameters

int sum(int a, int b)
{
	return a + b;
}

int main()
{
	int x = 10;
	int y = 20;
	sum(x, y);
	sum(10, 20);
}

其中，a和b是形参，x、y、10、20是实参。形参是左值，而实参可能是左值，也可能是右值。

2 通用引用和右值引用

2.1 概念

右值引用：主要存在原因是为了识别可移动操作的对象。

通用引用：保留绑定对象的左值/右值和const性质。

因为通用引用是引用，所以它们必须被初始化。一个通用引用的初始值决定了它是代表了右值引用还是左值引用。如果初始值是一个右值，那么通用引用就会是对应的右值引用，如果初始值是一个左值，那么通用引用就会是一个左值引用。对那些是函数形参的通用引用来说，初始值在调用函数的时候被提供：

template<typename T>
void f(T&& param);              //param是一个通用引用

Widget w;
f(w);                           //传递给函数f一个左值；param的类型
                                //将会是Widget&，即左值引用

f(std::move(w));                //传递给f一个右值；param的类型会是
                                //Widget&&，即右值引用

2.2 区别

对于通用引用，类型推导是必要的。

2.2.1 两种情况会出现通用引用

//函数模板形参
template<typename T>
void f(T&& param);

//auto声明符
auto&& var2 = var1;

2.2.2 标准的右值引用

void f(Widget&& param);         //没有类型推导，
                                //param是一个右值引用
Widget&& var1 = Widget();       //没有类型推导，
                                //var1是一个右值引用

2.2.3 易被理解成通用引用的右值引用

  1. 虽然类型T会被推导，但param的类型声明不是T&&，而是std::vector<T>&&，因此param是一个右值引用。
template <typename T>
void f(std::vector<T>&& param);     //param是一个右值引用

//此时如果传递左值实参会报错
std::vector<int> v;
f(v);
  1. push_back函数在有一个特定的vector实例之前不可能存在，而实例化vector时，类型已经确定了，进而也决定了push_back的声明。
template<class T, class Allocator = allocator<T>> 
class vector
{
public:
    void push_back(T&& x);
    …
}

例如：实例化以下对象时，

std::vector<Widget> v;

std::vector模板会被实例化为以下代码，因此push_back这里的形参总会是右值引用而不是通用引用。

class vector<Widget, allocator<Widget>> {
public:
    void push_back(Widget&& x);             //右值引用
    …
};
  1. const T&&和const auto&&都是右值引用，因为通用引用必须能同时绑定左值和右值，而const破坏了这一特性。

3 std::move

3.1 作用

仅仅是执行转换（cast）的函数模板，无条件的将它的实参转换为右值。

3.2 内部实现示例

并不满足标准细则，但接近

  • C++11：
//在std命名空间
template<typename T>                            
typename remove_reference<T>::type&& move(T&& param)
{
    using ReturnType = typename remove_reference<T>::type&&;

    return static_cast<ReturnType>(param);
}

解析：
1、返回类型是typename remove_reference<T>::type&&，代表一个去除引用修饰（因为引用折叠，所以要去除引用修饰），得到原始类型，再添加&&，使其成为右值引用的类型。
2、参数T&& param是通用引用，可以接受任何类型的参数（左值或右值）。
3、用using将typename remove_reference<T>::type&&声明为ReturnType
4、最后用static_cast将参数强制转换为右值引用。

  • C++14：
//在std命名空间
template<typename T>
decltype(auto) move(T&& param)
{
    using ReturnType = remove_referece_t<T>&&;
    return static_cast<ReturnType>(param);
}

3.3 使用示例

用std::move实现以下移动构造函数

class Widget {
public:
    Widget(Widget&& rhs)
    : s(std::move(rhs.s))
    {
    }
    …

private:
    std::string s;
};

3.4 注意

const右值作为构造函数的实参，会调用拷贝构造函数而不是移动构造函数。因为不允许const对象被传递给可以修改他们的函数（例如移动构造函数）

  • 示例：
class Annotation {
public:
    explicit Annotation(const std::string text)
    ：value(std::move(text))    //“移动”text到value里；这段代码执行起来
    { … }                       //并不是看起来那样
    
    …

private:
    std::string value;
};

上面的std::string value构造时调用的是下面的拷贝构造函数而不是移动构造函数。

class string {                  //std::string事实上是
public:                         //std::basic_string<char>的类型别名
    …
    string(const string& rhs);  //拷贝构造函数
    string(string&& rhs);       //移动构造函数
    …
};

4 std::forward

4.1 作用

只对绑定了右值的引用进行右值转换。

4.2 使用

假设函数模板logAndProcess用来将通用引用形参传递给函数process处理。这里重载了两个process函数版本分别处理左值和右值。

void process(const Widget& lvalArg);        //处理左值
void process(Widget&& rvalArg);             //处理右值

template<typename T>
void logAndProcess(T&& param)
{
    process(std::forward<T>(param));
}

传入左值w作为实参时，形参param会被类型推导为Widget&（左值引用），std::forward也会返回左值引用，所以会调用process(const Widget& lvalArg);。

传入std::move(w)作为实参时，传入的实参类型是Widget&&，T会被推导为Widget，param会被推导为Widget&&类型。此时，param本身是左值，但它的类型是Widget&&（右值引用）类型。std：：forward也会返回右值引用类型，所以会调用void process(Widget&& rvalArg);。

Widget w;

logAndProcess(w);               //用左值调用
logAndProcess(std::move(w));    //用右值调用

5 std::move和std::forward的使用场景

5.1 右值引用-std::move，通用引用-std::forward

  • 当把右值引用转发给其他函数时，右值引用应该无条件转换为右值（通过std::move）
class Widget {
public:
    Widget(Widget&& rhs)        //rhs是右值引用
    : name(std::move(rhs.name)),
      p(std：：move(rhs.p))
      { … }
    …
private:
    std::string name;
    std::shared_ptr<SomeDataStructure> p;
};
  • 当转发通用引用时，通用应用应该有条件的转换为右值（通过std::forward）
class Widget {
public:
    template<typename T>
    void setName(T&& newName)           //newName是通用引用
    { name = std::forward<T>(newName); }

    …
};

  • 当转发右值引用时使用std::forward可能会导致的问题：

    由于需要传递一个模板实参，就会有更多的犯错的可能，如果模板实参传递std::string&会导致rhs.s转发为左值，进而导致成员变量std::string s被复制而不是被移动构造。

class Widget{
public:
    Widget(Widget&& rhs)                    //不自然，不合理的实现
    : s(std::forward<std::string>(rhs.s))
    {
    }

    …

}

  • 当转发通用引用时使用std::move可能会导致的问题——意外改变左值：

    一个局部变量左值n作为参数传入setName后，被转发为一个右值，移动给了成员变量name，此时n变成了未定义的值。

class Widget {
public:
    template<typename T>
    void setName(T&& newName)
    { name = std::move(newName); } 
    …

private:
    std::string name;
    std::shared_ptr<SomeDataStructure> p;
};

std::string getWidgetName();        //工厂函数

Widget w;

auto n = getWidgetName();           //n是局部变量，一个左值

w.setName(n);                       //把左值n转为右值移动进w

…                                   //现在n的值未知

5.2 在最后一次时使用

函数中多次使用绑定到右值引用或通用引用的对象，要确保在完成其他操作前，这个对象不会被移动。于是，在最后一次使用时使用std::move和std::forward。

template<typename T>
void setSignText(T&& text)                  //text是通用引用
{
  get1(text);                       //使用text但是不改变它
  
  get2(std::forward<T>(text));        //有条件的转换为右值
}

5.3 按值返回右值引用或通用引用形参时

这里返回一个右值引用的形参，优先通过std::move将其转换为右值。

Matrix operator+(Matrix&& lhs, const Matrix& rhs) //按值返回
{
    lhs += rhs;
    return std::move(lhs);          //移动lhs到返回值中
}

如果直接返回左值，会强制编译器拷贝它到返回值的内存空间。而将其转换为右值，如果Matrix支持移动操作，就会提高代码效率；如果不支持，右值也可以被Matrix的拷贝构造函数拷贝，不会出现问题。

Matrix operator+(Matrix&& lhs, const Matrix& rhs)
{
    lhs += rhs;
    return lhs;                     //拷贝lhs到返回值中
}

按值返回通用引用形参时，也是同样优先使用std::forwad返回。

5.4 避免使用的情况

以下可能会抑制编译器优化，导致性能下降

Widget makeWidget()                 //makeWidget的移动版本
{
    Widget w;
    …
    return std::move(w);
}

5.4.1 RVO

返回值优化（return value optimization，RVO）

作用：C++标准中已经实现了，只要满足RVO的条件，针对以下例子，编译器会避免拷贝局部变量w，而直接在分配给函数返回值的内存中构造w来实现。

RVO满足条件：返回一个局部对象，局部对象与函数返回值的类型相同

Widget makeWidget()
{
    Widget w;
    …
    return w;                       
}

5.4.2 隐式移动

对于有些很难让编译器实现RVO的情况，比如控制路径返回不同局部变量时：

Widget makeWidget(bool flag) {
    Widget w1, w2;
    if (flag) return w1; // 可能无法优化
    else return w2;      // 因为编译器需在运行时决定构造哪个对象
}

或不满足RVO条件，按值返回函数形参：

Widget makeWidget(Widget w)         //传值形参，与函数返回的类型相同
{
    …
    return w;
}

C++标准规定，如果一个函数返回一个局部变量或传值形参，若未RVO优化，则隐式将返回对象当做右值处理，也就是以上两段代码会被编译器看作：

Widget makeWidget(bool flag) {
    Widget w1, w2;
    if (flag) return std：：move(w1); // 可能无法优化
    else return std：：move(w2);      // 因为编译器需在运行时决定构造哪个对象
}

Widget makeWidget(Widget w)
{
    …
    return std：：move(w);
}

6 通用引用与重载

6.1 避免在通用引用上重载

原因：通用引用几乎可以精准匹配任何类型的实参。

例1：（这里重载是为了传字符串走完美转发重载版本，传整型走int重载版本）传入short，通用引用推导的类型是short，因此匹配优先级高于int，所以调用通用引用重载版本，进而出错。

//通用引用版本
template<typename T>
void logAndAdd(T&& name)
{
    names.emplace(std::forward<T>(name));
}

//传入int的重载版本
std::string nameFromIdx(int idx);   //返回idx对应的名字
void logAndAdd(int idx)
{
    names.emplace(nameFromIdx(idx));
}


std::string petName("Darla");           
logAndAdd(petName);                     //调用T&&重载版本
logAndAdd(std::string("Persephone"));   //调用T&&重载版本
logAndAdd("Patty Dog");                 //调用T&&重载版本

logAndAdd(22);                          //调用int重载版本

short nameIdx;
logAndAdd(nameIdx);                     //错误！

例2：（这里第二个构造函数希望去调用拷贝构造函数）手动添加构造函数重载或编译器生成也会出现一样问题，这里传p不会调用拷贝构造，而会调用完美转发的构造函数，而完美转发构造函数内部需要的类型是string而不是Person，编译出错。

class Person {
public:
    template<typename T>            //完美转发的构造函数
    explicit Person(T&& n)
    : name(std::forward<T>(n)) {}

    explicit Person(int idx);       //int的构造函数

    Person(const Person& rhs);      //拷贝构造函数（编译器生成）
    Person(Person&& rhs);           //移动构造函数（编译器生成）
};

Person p("Nancy"); 
Person copyP(p);                   //从p创建新Person；这通不过编译！

原因：Person p匹配实例化后的完美转发构造函数更精准，所以会调用完美转发构造函数。如果是const Person p("Nancy")，则两者一样会优先调用拷贝构造函数。

class Person {
public:
    explicit Person(Person& n)          //传入p实例化的完美转发构造函数
    : name(std::forward<Person&>(n)) {}


    Person(const Person& rhs);          //拷贝构造函数（编译器生成的）
    …
};

例3：甚至基类声明了完美转发构造函数，派生类实现自己的拷贝和移动构造函数时会调用基类的完美转发构造函数而不是基类的拷贝或者移动构造。因为实际派生类传递给基类构造函数的参数类型是SpecialPerson。

class SpecialPerson: public Person {
public:
    SpecialPerson(const SpecialPerson& rhs) //拷贝构造函数，调用基类的
    : Person(rhs)                           //完美转发构造函数！
    { … }
    
    SpecialPerson(SpecialPerson&& rhs)      //移动构造函数，调用基类的
    : Person(std::move(rhs))                //完美转发构造函数！
    { … }
    
    …
};

6.2 同时使用通用引用和重载的办法

6.2.1 标签分派tag dispatch

继续以前面的例子为例：封装一个函数logAndAddImpl实现具体功能以及重载，如果std::is_integral<typename std::remove_reference<T>::type>()接收到的参数是int，则会调用下面第二个形参为std::true_type的重载版本；反之则调用第二个形参为std::false_type的重载版本。

template<typename T>
void logAndAdd(T&& name)
{
    logAndAddImpl(
        std::forward<T>(name),
        //因为左值会被推导为T&，而int&不是整型类型（引用不是整型类型）
        //因此需要去引用性
        std::is_integral<typename std::remove_reference<T>::type>()
    );
}

template<typename T>                            
void logAndAddImpl(T&& name, std::false_type)   
{
    auto now = std::chrono::system_clock::now();
    log(now, "logAndAdd");
    names.emplace(std::forward<T>(name));
}

std::string nameFromIdx(int idx);           
void logAndAddImpl(int idx, std::true_type) 
{
  logAndAdd(nameFromIdx(idx)); 
}

6.2.2 std::enable_if

版本1：应对构造函数使用通用引用的问题

  1. typename std::decay<T>::type表示移除引用和const或volatile标识符的修饰。
  2. std::is_same用来比较两种类型，此时配合std::decay即Person、Person&、Person&&、const Person、volatile Person 、const volatile Person等都和Person一样。
  3. std::is_same<T1, T2>::value获取bool值作为条件。
  4. typename = typename std::enabe_if<conditon>::type指condition为true时才会启用这个模板。
class Person {
public:
    template<
        typename T,
        typename = typename std::enable_if<
            !std::is_same<Person, typename std::decay<T>::type>
            ::value>
            ::type>
    explicit Person(T&& n);
    …
};

版本2：用std::is_base_of代替std::is_same可以额外应对派生类拷贝和移动构造函数错误调用基类完美转发构造函数的问题。

class Person {
public:
    template<
        typename T,
        typename = typename std::enable_if<
            !std::is_base_of<Person, typename std::decay<T>::type>
            ::value>
            ::type>
    explicit Person(T&& n);
    …
};

版本3：除了区分拷贝和移动构造函数，还可以额外区分整型有参构造函数和完美转发构造函数

//C++14风格
class Person {
public:
    template<
        typename T,
        typename = std::enable_if_t<
            !std::is_base_of<Person, std::decay_t<T>>::value
            &&
            !std::is_integral<std::remove_reference_t<T>>::value
        >
    >
    explicit Person(T&& n)          //对于std::strings和可转化为
    : name(std::forward<T>(n))      //std::strings的实参的构造函数
    { … }

    explicit Person(int idx)        //对于整型实参的构造函数
    : name(nameFromIdx(idx))
    { … }

    …                               //拷贝、移动构造函数等

private:
    std::string name;
};

7 可能失败的完美转发

完美转发标准模板：

template<typename... Ts>
void fwd(Ts&&... params)            //接受任何实参
{
    f(std：：forward<Ts>(params)...); //转发给f
}

完美转发失败原因：编译器不能推导出fwd的一个或多个形参类型；编译器推导“错”了fwd的一个或者多个形参类型（将推导出的类型传入f和直接将原实参传入f表现出不一致的行为）。

7.1 花括号初始化

设定f声明为：

void f(const std：：vector<int>& v) ;

直接用花括号初始化调用f会将std::initializer_list与f形参关联，然后隐式转换为std::vector<int>，因此可以。

用花括号初始化调用fwd，则不会形参关联，而是首先会执行类型推导。这时因为函数模板无法将花括号初始化推导为std::initializer_list，因此错误。

f({1, 2, 3}); //可以
fwd({1, 2, 3}); //错误

解决办法：先使用auto推导类型（auto可以推导出花括号初始化的类型为std::initializer_list），声明一个局部变量，再将局部变量传进转发函数。

auto il = {1, 2, 3};
fwd(il);

7.2 0或者NULL作为空指针

如果f声明的形参是一个指针，这时候fwd传入0或NULL则会推导为整型，与f声明的形参类型不同，因此错误。

解决办法：传入nullptr而不是0或NULL。

7.3 没在类外定义的static const整型成员变量

7.3.1 常量传播

只有整型static const成员变量可以不在类外定义，只需在类内声明，此时编译器不会为其留存空间，直接将声明的值放入需要这个变量的地方。

class Widget {
public:
    static const std::size_t MinVals = 28;  //MinVal的声明
    …
};
…                                           //没有MinVals定义

std::vector<int> widgetData;
widgetData.reserve(Widget::MinVals);        //使用MinVals

此时如果有地方有使用Widget::MinVals的地址，就会出现链接错误。在类外提供它的定义则可解决这个问题。

7.3.2 失败原因

尽管代码中没有使用MinVals的地址，但fwd的形参是通用引用就会被视为有取地址的操作，引发链接错误。同样可以在类外提供MinVals的定义解决。

f(Widget::MinVals); //可以，视为“f(28)”

fwd(Widget::MinVals); //错误！不应该链接

7.4 将重载的函数作为参数传入转发函数中

设f被声明为：

void f(int pf(int));

设有重载函数，processVal

int processVal(int value);
int processVal(int value, int priority);

一般情况下将重载函数作为参数传入函数时，可以根据f声明的形参去匹配重载函数，但fwd没有声明具体的形参类型，所以会失败

f(processVal); //可以

解决办法：定义一个显示函数指针指向重载函数，将此显示函数指针传入fwd

int (*processValPtr)(int) = processVal;
fwd(processValPtr);

将函数模板作为参数传入转发函数中也有同样问题，解决办法同样是显示指定传入的函数模板的指针类型。

template<typename T>
T workOnVal(T param)                //处理值的模板
{ … }

fwd(workOnVal);                     //错误！
fwd(static_cast<int (*)(int)>(workOnVal)); //正确
《Modern Effective C++》学习笔记5 右值引用，移动语义和完美转发
slxixiha的博客
07-27 216
第五章：右值引用，移动语义和完美转发 移动语义：提供了比复制操作代价低得多的移动操作，提升了代码的性能； 完美转发：使得人们可以撰写接受任意实参的函数模板，并将其转发到其他函数，目标函数会接受到与转发函数所接受的完全相同的实参。 条款二十三：理解std::move和std::forward 这两个函数看起来是函数，其实它们在运行期间什么也不做，也不生成任何可执行代码。 std::move并不进行任何移动，它只是无条件地将实参强制转换成右值。 std::forward也不进行任何转发，它只是在某个
Modern C++ 学习笔记 —— 右值、移动篇
小小笑笑川的博客
05-26 1025
C++11引入的最关键的特性就是右值，进而扩展出移动，万能引用，完美转发等概念，本文对这些概念做了详细介绍以及惯用手法，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
Effective Modern C++ 笔记五： 右值引用，移动语义和完美转发
qq_33776188的博客
07-24 311
形参总是左值，即使其类型是右值引用 void f(Widget&& w); w是个左值，即使它的型别是个指涉到Widget型别对象的右值引用。 条款23：理解std::move和std::forward std::move无条件地将实参强制转换成右值。 std::forward仅在某个特定条件满足时才执行同一个强制转换。 template<typename T> typename remove_reference<T>::type&&am...
现代 c++ 三：移动语义与右值引用
antsmall的专栏
05-27 857
从历史角度讲清楚c++11的右值引用的来龙去脉
Effective Modern C++ 学习笔记
weixin_70354558的博客
04-24 382
记录下阅读此书的感想与总结，一方面能巩固复习，另一方面也能更好地浓缩本书的精华，方便日后的回看。
【Effective Modern C++】Chapter 5 右值引用、移动语义和完美转发
yyt_1995的博客
07-24 251
Chapter 5 右值引用、移动语义和完美转发 移动语义：用移动操作来替代昂贵的复制操作。 完美转发：函数模板转发其他函数，目标函数将接收到与转发函数所接受的完全相同的实参。 右值引用：让移动语义和完美转发成为可能。 实际情况： std::move其实并没有移动任何东西… 完美转发并不完美… 移动操作的成本并不一定比复制低… 移动语境中不一定能调到移动操作… "type&&"并不总是表示右值引用… C++规则：形参总是左值，即使其型别是右值引用。 23. std::move &
effective modern C++ 学习笔记2
yajuan的专栏
04-17 652
有一个形参中没有任何一个具备std::initializer_list型别的构造函数，允许你明确初始的容器大小以及每个元素的初始值，但是它也有一个std::initializer_list构造函数允许你明确初始的容器值。一个概念上的可变参的。nullptr 的类型实际上是 std::nullptr_t ，在一个漂亮的循环下， std::nullptr_t 定义为 nullptr 的类型。std::nullptr_t 可以隐式的转换为所有的裸指针类型，这使得 nullptr 表现的像可以指向任意类型的指针。
Modern Effective C++ 条款二十四：区分通用引用与右值引用
_
11-30 713
Args&&... args 是一个通用引用，因为形式是 type&&，并且 Args 的类型会在每次调用时被推导。初始值决定引用类型：通用引用的初始值决定了它是左值引用还是右值引用。MyTemplateType 可以是任何类型，param 是一个通用引用，因为其形式是 type&&，并且 MyTemplateType 的类型会在调用时被推导。auto&& 声明的变量是通用引用，因为会发生类型推导，并且形式是 type&&。当 T&& 用在一个有类型推导的地方时，它被称为通用引用或转发引用。
《Effective Modern C++》学习笔记 - Chapter 5. 右值引用，移动语义和完美转发
アルタイル
01-24 528
第五章 第一次学习时，移动语义和完美转发的意思看起来很直白： 移动语义使编译器能把昂贵的拷贝操作换为移动操作。类似于拷贝构造/赋值函数，你可以通过移动构造/赋值函数来控制移动的语义。移动语义还允许你创建仅移动（不能复制）的类型，如 std::unique_ptr，std::future 和 std::thread。 完美转发允许函数模板接受任意（左值/右值）参数，并将它们原样传递给其它的函数。 右值引用是使以上二者可能实现的低层语言机制 然而随着对这些特性的掌握变深，你会发现最初的印象只是冰
Effective.Modern.C++中文版和英文版.zip
06-09
《Effective Modern C++》是C++编程领域的一本经典书籍，由Scott Meyers撰写，旨在帮助程序员充分利用C++11及以后版本的新特性，提升代码质量和效率。这本书包含了一系列实践性的编程建议，涵盖了模板、智能指针、...
Effective Modern C++ 完全解读笔记汇总
Dong_HFUT的博客
10-04 7481
Effective Modern C++ 系列学习和解读笔记汇总。
题解 洛谷 Luogu P1073 [NOIP 2009 提高组] 最优贸易 强连通分量 Tarjan 缩点 拓扑排序 动态规划 C++
qwq_ovo_pwp的博客
05-07 616
思路：有两个目标，目标一：至多买入一次卖出一次，使收益最大 (不会低于 0)。目标二：以 1 为起点，以 n 为终点 (保证从 1 可达 n)。我们只能先买入再卖出，为了完成目标一，我们显然需要知道最低买入价、最高卖出价，即，以某个节点 x 为中点时，x 及其之前的最低价、x 及其之后的最高价。这些信息可以通过 DP 得到，且需要正向建图 DP (得到 x 及其之前的最低价)、反向建图 DP (得到 x 及其之后的最高价) 共计两轮 DP。无特殊性质的有向图不便于 DP，我们可以考虑缩点。缩点后，只要知道每
深入探讨C++日志模块设计与实现
weixin_44727517的博客
05-07 537
日志系统是软件开发的"黑匣子"，在调试跟踪、问题定位、运行监控等方面发挥关键作用。一个优秀的日志模块应具备：精准的问题定位能力灵活的输出控制最小的性能损耗可靠的运行稳定性。
C++之红黑树
最新发布
H2X7_的博客
05-11 383
在这之前，我们学习了AVL树，它是一棵二叉搜索树，它通过平衡因子（balance factor)来保证平衡（子树之间的高度差保持在一定的范围之内），它从本质上提高了二叉搜索树的搜查效率。而这节我们再来学习一种二叉搜索树——红黑树。这种二叉搜索树的树结点上增加了一个属性——颜色，颜色为红色或黑色。通过对各节点上的颜色进行约束从而使得整个树平衡。
C++双重释放内存问题
weixin_40398522的博客
05-09 399
在C++中，双重释放内存会导致未定义行为，通常引发程序崩溃这是因为同一块内存被多次释放会破坏内存管理器的内部数据结构双重释放是什么意思呢？
基于QT(C++)实现（图形界面）校园导览系统
神仙别闹的自留地
05-07 1162
本校园导览系统基本实现了校园内的导航，支持两个校区的导览，教学楼、图书馆、宿舍、体育馆等近50个建筑，360个顶点，近700条边，并可以查询到校园内各种建筑物及服务设施的相关信息。在导航时，支持最短距离、最短时间、途径最短距离及交通工具的最短时间等四个策略，通过图形化界面实现了模拟导航，在导航时用户可以实时查询周边建筑信息，并可设置当前模拟导航的时间速率。本系统可以记录当前运行情况的日志文件，如学生状态变化和键入信息。
C/C++ 路由跟踪小程序实现
liulilittle的博客
05-08 282
复制代码到新建 traceroute.c 文件之中。
C++—智能指针
aaa114514aaaa的博客
05-10 960
有关C++智能指针的学习【智能指针的应用场景】【RAII思想】【智能指针如何使用】【c++各种智能指针的特点和使用并模拟实现】【智能指针的缺陷(如unique_ptr无法拷贝)(shared_ptr的线程安全和循环引用问题)】【定制删除其】
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

歪比不是小巴卜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值