c++ primer读书笔记-第十四章 重载操作符与转换

CARLA仿真:自定义地图与AI车辆行为编程 CARLA仿真:自定义地图与AI车辆行为编程 ,人工智能,计算机视觉,大模型,AI,本文围绕CARLA仿真平台,介绍了其基础功能与安装方法,详解地图系统,包括预设地图的加载切换及自定义地图的创建、导入与优化。还阐述了AI车辆的创建、属性设置、销毁,以及行为控制,如交通规则遵守、路径规划、复杂行为编程和行为树应用。同时涉及传感器与车辆感知、交通场景构建、自定义地图与AI行为结合应用、高级应用,以及常见问题解决方案和学习资源,为CARLA仿真应用提供全面指导。 阅读详情

C++ 允许我们重定义操作符用于类类型对象时的含义。如果需要,可以像内置转换那样使用类类型转换,将一个类型的对象隐式转换到另一类型。
例如标准库为容器类定义了几个重载操作符。这些容器类定义了下标操作符以访问数据元素,定义了 * 和 -> 对容器迭代器解引用。

重载操作符的定义

1.重载操作符是具有特殊名称的函数:保留字 operator后接需定义的操作符号。像任意其他函数一样,重载操作符具有返回类型和形参表,如下语句(+操作符为非类成员操作符,需显示声明两个形参表明是左右操作数):

Sales_item operator+(const Sales_item&, const Sales_item&); 

声明了加号操作符,可用于将两个 Sales_item 对象“相加”并获得一个 Sales_item 对象的副本。
除了函数调用操作符之外,重载操作符的形参数目(包括成员函数的隐式
this 指针)与操作符的操作数数目相同。函数调用操作符可以接受任意数目的操作数。
可重载和不可重载的操作符
这里写图片描述

2.重载操作符必须具有至少一个类类型或枚举类型(第 2.7 节)的操作数。这条规则表明:重载操作符不能重新定义用于内置类型对象的操作符的含义。

3.重载后的操作符优先级和结合性是固定的

在 && 和 || 的重载版本中,两个操作数都要进行求值,而且对操作数的求值顺序不做规定。因此,4.重载 &&、|| 或逗号操作符不是一种好的做法。

5.类成员与非成员
作为类成员的重载函数,其形参看起来比操作数数目少1。作为成员函数的操作符有一个隐含的 this 形参,限定为第一个操作数。
类成员操作符:

Sales_item& Sales_item::operator+=(const Sales_item&);

非类成员操作符

Sales_item operator+(const Sales_item&, const Sales_item&); 

6.操作符重载和友元关系
操作符定义为非成员函数时,通常将它们设置为所操作类的友元函数,以便该操作符函数可以访问该类的私有成员。
但若无需访问类私有成员时,可不必设为友元函数。
类中声明==操作符为友元函数:

class Sales_item {
friend bool operator==(const Sales_item&, const Sales_item&);
//...
}

在函数中可以直接访问Sales_item的私有成员:

inline bool 
operator==(const Sales_item &lhs, const Sales_item &rhs)
{
    // must be made a friend of Sales_item
    return lhs.units_sold == rhs.units_sold &&
           lhs.revenue == rhs.revenue &&
       lhs.same_isbn(rhs);
}

7.使用重载操作符
使用重载操作符的方式,与内置类型操作数上使用操作符的方式一样。

cout << item1 + item2 << endl;

这个表达式隐式调用为 Sales_items 类而定义的 operator+。

也可以像调用普通函数一样调用重载操作符函数,指定函数并传递适当类型适当数目的形参(下面调用了一个非成员操作符+):

cout << operator+(item1, item2) << endl;

调用成员操作符函数:

    item1 += item2;
item1.operator+=(item2);

第一种情况下,使用表达式语法隐式调用重载操作符函数:第二种情况下,在 item1 对象上调用成员操作符函数。

重载操作符的设计

通常不重载具有内置含义的操作符

赋值操作符、取地址操作符和逗号操作符对类类型操作数有默认含义。如果没有特定重载版本,编译器就自己定义以下这些操作符。
• 合成赋值操作符(第 13.2节)进行逐个成员赋值:使用成员自己的赋值:使用成员自己的赋值操作依次对每个成员进行赋值。
• 默认情况下,取地址操作符(&)和逗号操作符(,)在类类型对象上的执行,与在内置类型对象上的执行一样。取地址操作符返回对象的内存地址,逗号操作符从左至右计算每个表达式的值,并返回最右边操作数的值。
• 内置逻辑与(&&)和逻辑或(||)操作符使用短路求值(第 5.2节)。如果重新定义该操作符,将失去操作符的短路求值特征。

大多数操作符对类对象没有意义

为类设计操作符,最好的方式是首先设计类的公用接口。定义了接口之后,就可以考虑应将哪些操作符定义为重载操作符。例如:
• 相等测试操作应使用 operator==。
• 一般通过重载移位操作符进行输入和输出。
• 测试对象是否为空的操作可用逻辑非操作符 operator! 表示。

复合赋值操作符

如果一个类有算术操作符(第 5.1 节)或位操作符(第 5.3 节),那么,提供相应的复合赋值操作符一般是个好的做法。例如,Sales_item 类定义了 += 操作符。

选择成员或非成员实现

下面是一些原则:
• 赋值(=)、下标([])、调用(())和成员访问箭头(->)等操作符必须定义为成员,将这些操作符定义为非成员函数将在编译时标记为错误。
• 像赋值一样,复合赋值操作符通常应定义为类的成员,与赋值不同的是,不一定非得这样做,如果定义非成员复合赋值操作符,不会出现编译错误。
• 改变对象状态或与给定类型紧密联系的其他一些操作符,如自增、自减和解引用,通常就定义为类成员。
• 对称的操作符,如算术操作符、相等操作符、关系操作符和位操作符,最好定义为普通非成员函数。

输入和输出操作符

输出操作符 << 的重载

为了与 IO 标准库一致,操作符应接受 ostream& 作为第一个形参(像是经常用标准库的cout作为实参),对类类型 const对象的引用作为第二个形参,并返回对 ostream 形参的引用。
重载输出操作符一般的简单定义如下:

ostream& operator <<(ostream& os, const ClassType &object) 
     { 
         // actual output of members 
         os << // ... 
         // return ostream object 
         return os; 
     }

第一个形参是对 ostream 对象的引用,在该对象上将产生输出。ostream 为非 const,因为写入到流会改变流的状态。
第二个形参一般应是对要输出的类类型的引用。该形参是一个引用以避免复制实参。

一般而言,输出操作符应输出对象的内容,进行最小限度的格式化,它们不应该输出换行符。

IO 操作符必须为非成员函数

若将该操作符定义为类的成员,左操作数将只能是该类型的对象。
则只能这样使用:

Sales_item item; 
item << cout;

输入操作符 >> 的重载

输出操作符类似,输入操作符的第一个形参是一个引用,指向它要读的流,并且返回的也是对同一个流的引用。它的第二个形参是对要读入的对象的非 const 引用,该形参必须为非const,因为输入操作符的目的是将数据读到这个对象中。
输入和输出操作符有如下区别:输入操作符必须处理错误和文件结束的可能性。
Sales_item 的输入操作符如下:

     istream& 
     operator>>(istream& in, Sales_item& s) 
     { 
         double price; 
         in >> s.isbn >> s.units_sold >> price; 
         // check that the inputs succeeded 
         if (in) 
            s.revenue = s.units_sold * price; 
         else 
            s = Sales_item(); // input failed: reset object to default state 
         return in; 
     } 
输入期间的错误
  1. 任何读操作都可能因为提供的值不正确而失败。例如,读入 isbn 之后,输入操作符将期望下两项是数值型数据。如果输入非数值型数据,这次的读入以及流的后续使用都将失败。
  2. 任何读入都可能碰到输入流中的文件结束或其他一些错误。
处理输入错误

如果输入操作符检测到输入失败了,则确保对象处于可用和一致的状态是个好做法。在Sales_item的输入操作符中,如果发生了错误,就将形参恢复为空 Sales_item 对象。

算术操作符和关系操作符

一般而言,将算术和关系操作符定义为非成员函数,像下面给出的
Sales_item 加法操作符一样:

Sales_item 
     operator+(const Sales_item& lhs, const Sales_item& rhs) 
     { 
         Sales_item ret(lhs);  // copy lhs into a local object that we'll return 
         ret += rhs;           // add in the contents of rhs 
         return ret; // return ret by value 
     } 

加法操作符并不改变操作符的状态,操作符是对 const 对象的引用;相反,它产生并返回一个新的 Sales_item对象,该对象初始化为 lhs 的副本。

算术操作符通常产生一个新值,该值是两个操作数的计算结果,它不同于任一操作数且在一个局部变量中计算,返回对那个变量的引用是一个运行时错误。

相等操作符

C++ 中的类使用相等操作符表示对象是等价的。即,它们通常比较每
个数据成员,如果所有对应成员都相同,则认为两个对象相等。
设计原则:
• 如果类定义了 == 操作符,该操作符的含义是两个对象包含同样的数据。
• 如果类具有一个操作,能确定该类型的两个对象是否相等,通常将该函数定义为 operator== 而不是创造命名函数。用户将习惯于用 == 来比较对象,而且这样做比记住新名字更容易。
• 如果类定义了 operator==,它也应该定义operator!=。用户会期待如果可以用某个操作符,则另一个也存在。

关系操作符

但是,如果将 operator< 仅定义为对 isbn 的比较,该定义将与前面 == 的定义不相容。(相同isbn的对象两者都不小于对方,一般认定为相等)
因为 < 的逻辑定义与 == 的逻辑定义不一致,所以根本不定义 < 会更好。

赋值操作符

类赋值操作符接受类类型形参,通常,该形参是对类类型的 const 引用,但也可以是类类型或对类类型的非 const 引用。
如果没有定义这个操作符,则编译器将合成它。类赋值操作符必须是类的成员,以便编译器可以知道是否需要合成一个。
赋值操作符可以重载。无论形参为何种类型,赋值操作符必须定义为成员函数,这一点与复合赋值操作符有所不同。

class string { 
     public: 
         string& operator=(const string &);      // s1 = s2; 
         string& operator=(const char *);        // s1 = "str"; 
         string& operator=(char);                // s1 = 'c'; 
         // .... 
      };

赋值必须返回对 *this 的引用

因为赋值返回一个引用,就不需要创建和撤销结果的临时副本。返回值通常是左操作数的引用。

下标操作符

可以从容器中检索单个元素的容器类一般会定义下标操作符,即 []。
下标操作符必须定义为类成员函数。

提供读写访问

定义下标操作符比较复杂的地方在于,它在用作赋值的左右操作符数时都应该能表现正常。
下标操作符出现在左边,必须生成左值,可以指定引用作为返回类型而得到左值。只要下标操作符返回引用,就可用作赋值的任意一方。
可以对 const 和非 const 对象使用下标也是个好主意。应用于 const 对象时,返回值应为 const 引用,因此不能用作赋值的目标。
类定义下标操作符时,一般需要定义两个版本:一个为非 const 成员并返回引用,另一个为 const 成员并返回 const 引用。

int &operator[] (const size_t); 
const int &operator[] (const size_t) const;

成员访问操作符

为了支持指针型类,例如迭代器,C++语言允许重载解引用操作符(*)和箭头操作符(->))。
箭头操作符必须定义为类成员函数。解引用操作不要求定义为成员,但将它作为成员一般也是正确的。

支持指针操作

重载解引用操作符(*)和箭头操作符(->))可以帮助实现智能指针类(第 13.5.1 节),来对多个对象进行计数。

class ScreenPtr { 
     public: 
         ScreenPtr(Screen *p): ptr(new ScrPtr(p)) { } 
         ScreenPtr(const ScreenPtr &orig): 
            ptr(orig.ptr) { ++ptr->use; }
         Screen &operator*() { return *ptr->sp; } 
         //->优先级大于*
         Screen *operator->() { return ptr->sp; } 
         const Screen &operator*() const { return *ptr->sp; } 
         const Screen *operator->() const { return ptr->sp; } 
     private: 
         ScrPtr *ptr; // points to use-counted ScrPtr class 
     }; 

对这个ScreenPtr类对象使用解引用操作符( * )和箭头操作符(->)时,可以直接操作到实际的对象。
使用:

ScreenPtr ps(new Screen(4,4));

ps的ptr成员指向一个ScrPtr对象,然后这个对象指向上述的Screen对象

重载解引用操作符

解引用操作符是个一元操作符。在这个类中,解引用操作符定义为成员,因此没有显式形参,该操作符返回对 ScreenPtr 所指向的 Screen 的引用。
像下标操作符一样,我们需要解引用操作符的 const 和非 const 版本。它们的区别在于返回类型:const 成员返回 const 引用以防止用户改变基础对象。

重载箭头操作符

它可能表现得像二元操作符一样:接受一个对象和一个成员名。对对象解引用以获取成员。不管外表如何,箭头操作符不接受显式形参。
这里没有第二个形参,因为 ->的右操作数不是表达式,相反,是对应着类成员的一个标识符。没有明显可行的途径将一个标识符作为形参传递给函数,相反,由编译器处理获取成员的工作。

使用重载箭头

可以这样使用 ScreenPtr 对象访问 Screen 对象的成员:

    ScreenPtr p(&myScreen);     // copies the underlying Screen 
    p->display(cout);

重载箭头操作符必须返回指向类类型的指针,或者返回定义了自己的箭头操作符的类类型对象。

自增操作符和自减操作符

自增(++)和自减(–)操作符经常由诸如迭代器这样的类实现,这样的类提供类似于指针的行为来访问序列中的元素。

定义前自增/前自减操作符

CheckedPtr& CheckedPtr::operator++() 
     { 
         if (curr == end) 
             throw out_of_range 
                   ("increment past the end of CheckedPtr"); 
         ++curr;                // advance current state 
         return *this; 
     }

这个自增操作符根据 end 检查 curr,从而确保用户不能将 curr 增量到超过数组的末端。如果 curr 增量到超过 end,就抛出一个 out_of_range 异常;否则,将 curr 加 1 并返回对象引用。

区别操作符的前缀和后缀形式

同时定义前缀式操作符和后缀式操作符存在一个问题:它们的形参数目和类型相同,普通重载不能区别所定义的前缀式操作符还是后缀式操作符。
为了解决这一问题,后缀式操作符函数接受一个额外的(即,无用的)int 型形参。使用后缀式操作符进,编译器提供 0 作为这个形参的实参。
后缀式操作符可以这样实现:

// postfix: increment/decrement object but return unchanged value 
     CheckedPtr CheckedPtr::operator++(int) 
     { 
         CheckedPtr ret(*this);        // save current value 
         ++*this;                      // advance one element,  checking the increment 
         return ret;                   // return saved state 
     } 

操作符的后缀式必须记住对象在加 1/减 1之前的当前状态。这些操作符定义了一个局部 CheckedPtr对象,将它初始化为 *this 的副本,即 ret是这个对象当前状态的副本。接着将原对象增量后,返回未增量的的对象副本ret。

显式调用前缀式操作符

如果想要使用函数调用来调用后缀式操作符,必须给出一个整型实
参值,而前缀不用:

parr.operator++(0);             // call postfix operator++ 
parr.operator++();         // call prefix operator++

调用操作符和函数对象

可以为类类型的对象重载函数调用操作符。一般为表示操作的类重载调用操作符。例如,可以定义名为 absInt 的结构,该结构封装将 int 类型的值转换为绝对值的操作:

struct absInt { 
         int operator() (int val) { 
             return val < 0 ? -val : val; 
         } 
     };

这个类定义了一个操作:函数调用操作符,该操作符有一个形参
并返回形参的绝对值。
通过为类类型的对象提供一个实参表而使用调用操作符,所用的方式看起来像一个函数调用:

 int i = -42; 
 absInt absObj; // object that defines function call operator
 unsigned int ui = absObj(i); // calls absInt::operator(int)

函数调用操作符必须声明为成员函数。一个类可以定义函数调
用操作符的多个版本,由形参的数目或类型加以区别。

定义了调用操作符的类,其对象常称为函数对象,即它们是行为类似函数的对象。

将函数对象用于标准库算法

函数对象经常用作通用算法的实参。

bool GT6(const string &s) 
     { 
         return s.size() >= 6; 
     } 

使用 GT6 函数 作为传给 count_if 算法的实参,以计算使 GT6 返回 true 的单词的数目:

vector<string>::size_type wc = 
                     count_if(words.begin(), words.end(), GT6);

直接使用函数名作参数等效于取函数地址 :&GT6

函数对象可以比函数更灵活

GT6 函数将 6 这个数字固化在它的定义中。count_if 算法运行只用一个形参且返回 bool 的函数。
通过将 GT6 定义为带函数调用成员类(GT_cls),可以获得所需的灵活性。

class GT_cls { 
     public: 
         GT_cls(size_t val = 0): bound(val) { } 
         bool operator()(const string &s) 
                            { return s.size() >= bound; } 
     private: 
         std::string::size_type bound; 
     };

使用 GT_cls 函数对象:

cout << count_if(words.begin(), words.end(), GT_cls(6)) 
          << " words 6 characters or longer" << endl;

向GT_cls构造函数传递不同的参数可以进行不同的比较。

标准库定义的函数对象

这些标准库函数对象类型是在 functional 头文件中定义的。
这里写图片描述

每个类表示一个给定操作符

每个标准库函数对象类表示一个操作符,即,每个类都定义了应用命名操作的调用操作符。
plus 模板中的调用操作符对两个操作数应用 + 运算。
有两个一元函数对象类:一元减(negate))和逻辑非(logical_not))。其余的标准库函数对象都是表示二元操作符的二元函
数对象类。

表示操作数类型的模板类型

每个函数对象类都是一个类模板,我们需要为该模板提供一个类型。

 plus<int> intAdd;         
 negate<int> intNegate;   
 int sum = intAdd(10, 20);          // sum = 30 
 sum = intAdd(10, intNegate(10));    // sum = 0
在算法中使用标准库函数
sort(svec.begin(), svec.end(), greater<string>());

传递函数对象greater,该类将产生一个调用操作符,调用基础对象的大于操作符。

函数对象的函数适配器

标准库提供了一组函数适配器,用于特化和扩展一元和二元函数对象。

  1. 绑定器,是一种函数适配器,它通过将一个操作数绑定到给定值而将二元函数对象转换为一元函数对象。
  2. 求反器,是一种函数适配器,它*将谓词函数对象的真值求反
    标准库定义了两个绑定器适配器:bind1st 和 bind2nd。
    bind1st 将给定值绑定到二元函数对象的第一个实参,bind2nd将给定值绑定到二元函数对象的第二个实参。
count_if(vec.begin(), vec.end(), 
              bind2nd(less_equal<int>(), 10));

该适配器bind2nd返回一个函数对象less_equal,该对象用 10 作右操作数应用 <= 操作符。

两个求反器:not1 和 not2。你可能已经想到的,not1 将一元函数对象的真值求反,not2 将二元函数对象的真值求反。

count_if(vec.begin(), vec.end(), 
             not1(bind2nd(less_equal<int>(), 10)));

果是对不 <= 10 的
那些元素进行计数。

转换与类类型

在第 12.4.4 节介绍过,可用一个实参调用的非 explicit 构造函数定义一个隐式转换,转换为类类型。当提供了实参类型的对象而需要一个类类型的对象时,编译器将使用该转换。
除了定义到类类型的转换之外,我们还可以定义从类类型的转换。即,我们可以定义转换操作符,给定类类型的对象,该操作符将产生其他类型的对象。
假定想要定义一个名为 SmallInt的类,该类实现安全小整数,这个类将使我们能够定义对象以保存与 8 位 unsigned char 同样范围的值,即,0 到 255。这个类可以捕获下溢和上溢错误,因此使用起来比内置 unsigned char 更安全。
我们希望这个类定义 unsigned char支持的所有操作。具体而言,我们想定义 5个算术操作符(+、-、*、/、%)及其对应的复合赋值操作符,4个关系操作符(<、<=、>、>=),以及相等操作符(==、!=)。

支持混合类型表达式
int operator+(int, const SmallInt&); 
     int operator+(const SmallInt&, int); 
     SmallInt operator+(const SmallInt&, const SmallInt&);

因为存在从任意算术类型到 int 的转换,这三个函数可以涵盖支持
SmallInt 对象的混合模式使用的要求。但是,它不能适当处理浮点类型等非int型的混合模式操作。

转换减少所需操作符的数目

C++ 提供了一种机制,利用这种机制,一个类可以定义自己的转换,应用于其类类型对象。

SmallInt si(3); 
     si + 3.14159;     // convert si to int, then convert to double 
  1. 将 对象si 转换为 int 值。
  2. 将所得 int 结果转换为 double 值并与双精度字面值常量 3.14159 相加,得到 double 值。

转换操作符

转换操作符是一种特殊的类成员函数。它定义将类类型值转变为其他类型值的转换。转换操作符在类定义体内声明,在保留字 operator 之后跟着转换的目标类型:

class SmallInt { 
     public: 
         SmallInt(int i = 0): val(i) 
         { if (i < 0 || i > 255) 
        throw std::out_of_range("Bad SmallInt initializer"); 
         } 
         operator int() const { return val; } 
     private: 
         std::size_t val; 
     }; 

转换函数必须是成员函数,不能指定返回类型(例如: int operator int(); ),并且形参表必须为空。
转换函数一般不应该改变被转换的对象,通常应定义为 const 成员。

使用类类型转换

只要存在转换,编译器将在可以使用内置转换的地方自动调用它。
• 在表达式中:

     SmallInt si; 
     double dval; 
     si >= dval          // si converted to int and then convert to double 

• 在条件中:

if (si)                // si converted to int and then con vert to bool 

• 在显式类型转换中:

        int ival; 
 SmallInt si = 3.541; // 
 instruct compiler to cast si to int 
 ival = static_cast<int>(si) + 3;
只能应用一个类类型转换

假设Integral对象能转换成SmallInt对象,SmallInt对象能转换成int型对象。
但是不能完成从 Integral 到 int 的直接转换,因为它需要两次类类型转换。

标准转换可放在类类型转换之前
void calc(SmallInt); 
short sobj; 
SmallInt(int) 
calc(sobj);

为了调用函数 calc(),应用标准转换将 dobj 从 double 类型转换
为 int 类型,然后调用构造函数 SmallInt(int) 将转换结果转换为 SmallInt 类型。

实参匹配和转换

SmallInt到int 的转换使 SmallInt 的用户能够对 SmallInt 对象使用所有算术和关系操作符,而且,用户可以安全编写将 SmallInt 和其他算术类型混合使用的表达式。定义一个转换操作符就能代替定义 48 个(或更多)重载操作符,类实现者的工作就简单多了。

实参匹配和多个转换操作符
class SmallInt { 
     public: 
         SmallInt(int = 0); 
         SmallInt(double); 
         operator int() const { return val; } 
         operator double() const { return val; } 
     private: 
         std::size_t val; 
     };

考虑最简单的调用非重载函数的情况:

void compute(int); 
     void fp_compute(double); 
     void extended_compute(long double); 
     SmallInt si; 
     compute(si);          // SmallInt::operator int() const 
     fp_compute(si);       // SmallInt::operator double() const 
     extended_compute(si); // error: ambiguous  

最后一个对 extended_compute的调用有二义性。可以使用任一转换函数,但每个都必须跟上一个标准转换来获得 long double,因此,没有一个转换比其他的更好,调用具有二义性

实参匹配和构造函数转换
void manip(const SmallInt &); 
     double d; int i; long l; 
     manip(d);     // ok: use SmallInt(double) to convert the argument 
     manip(i);     // ok: use SmallInt(int) to convert the argument 
     manip(l);     // error: ambiguous

第三个调用具有二义性。没有构造函数完全匹配于long。使用每一个构造函数之前都需要对实参进行转换:
1. 标准转换(从 long 到 double)后跟 SmallInt(double) 的构造函数。
2. 标准转换(从 long 到 int)后跟 SmallInt(int)。

避免二义性最好的方法是避免编写互相提供隐式转换的成对的类。

重载确定和类的实参

正如我们看到的,在需要转换函数的实参时,编译器自动应用类的转换操作符或构造函数。因此,应该在函数确定期间考虑类转换操作符。函数重载确定(第 7.8.2 节)由三步组成:
1. 确定候选函数集合:这些是与被调用函数同名的函数。
2. 选择可行的函数:这些是形参数目和类型与函数调用中的实参相匹配的候选函数。选择可行函数时,如果有转换操作,编译器还要确定需要哪个转换操作来匹配每个形参。
3. 选择最佳匹配的函数。

显式强制转换消除二义性
compute(static_cast<int>(si)); // ok: convert and call compute(int) 
标准转换和构造函数
class SmallInt { 
     public: 
         SmallInt(int = 0); 
     }; 
     class Integral { 
     public: 
         Integral(int = 0); 
     }; 

     void manip(const Integral&); 
     void manip(const SmallInt&); 
     manip(10); // error: ambiguous

Integral 和 SmallInt 这两个类都提供接受 int 参数的构造函数,其中任意一个构造函数都可以与 manip的一个版本相匹配,因此,函数调用有二义性。

显式构造函数调用消除二义性
manip(SmallInt(10));    // ok: call manip(SmallInt) manip(Integral(10));    // ok: call manip(Integral)

重载、转换和操作符

重载操作符就是重载函数。使用与确定重载函数调用一样的过程来确定将哪个操作符(内置的还是类类型的)应用于给定表达式。

转换和操作符

下面几条经验规则:
1. 不要定义相互转换的类,即如果类 Foo 具有接受类 Bar 的对象的构造函数,不要再为类 Bar 定义到类型 Foo 的转换操作符。
2. 避免到内置算术类型的转换。具体而言,如果定义了到算术类型的转换,则
o 不要定义接受算术类型的操作符的重载版本。如果用户需要使用这些操作符,转换操作符将转换你所定义的类型的对象,然后可以使用内置操作符。
o 不要定义转换到一个以上算术类型的转换。让标准转换提供到其他算术类型的转换。

转换可能引起内置操作符的二义性
operator+(const SmallInt&, const SmallInt&);

试图进行混合模式运算,将会遇到二义性问题:

SmallInt s1, s2; 
 SmallInt s3 = s1 + s2; // ok: uses overloaded operator+ 
 int i = s3 + 0;                // error: ambiguous

第二个加有二义性,问题在于,可以将 0 转换为 SmallInt 并使用 + 的 SmallInt 版本,也可以将 s3 转换为 int 值并使用 int 值上的内置加操作符。

## 小结:
成员操作符有一个隐式 this 指针,该指针一定是第一个操作数,即,一元操作符唯一的操作数,二元操作符的左操作数。

重载了 operator()(即,函数调用操作符)的类的对象,称为“函数对象”。这种对象通常用于定义与标准算法结合使用的谓词函数。

内置类型通过调用类构造函数进行隐式转换, 类类型可以通过重载转换操作符进行隐式转换。

必须注意避免设计对用户而言不明显的操作符和转换,而且应避免定义一个类型与另一类型之间的多个转换。

Arch Linux 命令大全,值得收藏! Arch Linux 是一款轻量级、高度可定制的 Linux 发行版,以其简洁和强大的特性深受高级用户喜爱。但对于新手来说,完全掌握 Arch Linux 的操作需要时间和实践。本文将为您详细介绍常用的 Arch Linux 命令,涵盖系统管理、文件操作、用户管理、软件安装与管理、网络配置和磁盘管理等内容,帮助您更高效地使用 Arch Linux。 阅读详情

相关推荐

PCIe ATS介绍

主机侧使用IOMMU完成设备地址到物理memory地址的转换,以及设备访问权限的检查。但如果所有PCIe设备都在进行DMA操作,则TA(Translation Agent)和ATPT(Address Translation and Protection Table)则会成为瓶颈,从而影响系统的latency。

maxwell2ic的博客 6027

C++ Primer Plus 笔记第十六章

string 和标准模板库 本章内容包括:     标准C++ string类     模板 auto_ptr、unique_ptr 和 shared_ptr     标准模板库(STL)     容器类     迭代器     函数对象     STL算法     模板 initializer_list 16.1 string 类    string 类由头文件 stri...

weixin_34123613的博客 758

消费级显卡跑大模型:RTX 3060 12G 部署 70 亿参数 AI 编程助手的优化实战

本文详细介绍了如何在消费级显卡RTX 3060 12G上,通过量化、投机解码和分页KV-Cache等核心优化技术,成功部署并流畅运行70亿参数的CodeLlama-7B编程助手。文章提供了从环境配置、模型准备到参数调优的完整实战笔记,实测显存占用降至7.3GB,生成速度达21.7 token/秒,为开发者和技术爱好者提供了可行的本地AI部署方案。

weixin_29053067的博客 1266

《C++ Primer》学习笔记/习题答案 总目录

文章目录前言专栏C++学习笔记目录第一章 - 快速入门第二章 - 变量和基本类型第三章 - 标准库类型第四章 - 数组和指针第五章 - 表达式第六章 - 语句第七章 - 函数第八章 - 标准 IO 库第九章 - 顺序容器第十章 - 关联容器第十一章 - 泛型算法第十二章 - 类第十三章 - 复制控制第十四章 - 重载操作符与转换第十五章 - 面向对象编程第十六章 - 模板和泛型编程第十七章 - 用...

种树最好的时间是10年前,其次是现在!!! 4万+

岭回归的MATLAB步骤

MATLAB 实现框架,它涵盖了从数据导入到岭回归的步骤,包括计算共线性、使用 MAE、MSE、R²、MAPE 进行评价,以及绘制相应的可视化图表。

subject625Ruben的博客 1091

别再用图片水印了!5种你可能不知道的文本隐写术实战

本文介绍了5种高效的文本隐写术,帮助创作者在不影响内容可读性的情况下嵌入版权信息。从零宽度字符到同形字替换,再到标点符号变形和行尾空格编码,这些技术为数字内容提供了轻量级版权保护方案,特别适用于社交媒体和电子合同等场景。

k8l9m0n的博客 226

C++ Primer 中文版 第5版 读书笔记

分离式编译如果想声明一个变量而非定义它,就在变量前添加关键字extern// 声明i,而非定义iint j;// 声明并定义j任何包含了显示初始化的声明即成为定义。我们能给由extern关键字标记的变量赋一个初始值,但是这么做也就抵消了extern的作用。extern// 定义变量能且只能被定义一次,但是可以多次声明标准库类型string表示可变长的字符序列// 列表初始化// 错误注意字符串字面值的结尾处还有一个空字符如前所述,switch的执行流程有可能会跨过某些case标签。

weixin_44623642的博客 1848

数字设计实验:自动售货机

本文旨在介绍数字设计实验:自动售货机的设计思路和实现代码

2401_83740084的博客 2230

《C++ Primer》 读书笔记——第十四章 重载运算与类型转换

第十四章 重载运算与类型转换 14.1 基本概念 • 重载运算符是具有特殊名字的函数:它们的名字由关键字operator和其后要定义的运算符号共同组成。 • 如果一个运算符函数是成员函数,则它的第一个运算对象绑定到隐式的this指针上 • 对于一个运算符函数来说,它或者是类的成员,或者至少含有一个类类型的参数:这一约定意味着当运算符作用于内置类型的运算对象时,我们无法改变该运算符的含义。 1、可以重载的运算符 通常情况下,不应该重载逗号,取地址,逻辑与和逻辑或运算符。 上述运算符的重载版本无法保存求值

youyadefeng1的博客 333

YOLOv11全网首发:注意力独家魔改 | 具有切片操作的SimAM注意力,魔改SimAM助力小目标检测

1)直接作为注意力使用,效果秒杀SimAM;2)高效和卷积结合,代替原始网络的卷积操作;

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 1577

perl 安装DBI和DBD

还可以从cpan.perl.org站点下载tar压缩文件形式的源代码发行版本,解压缩后,切换到相应的文件目录 cd DBI-1.54 perl Makefile.PL make make test make install 安装DBD时候 需要export ORACLE_HOME 验证安装: perldoc DBD::Oracle perldoc DBI 在线文档; perldoc -m

zhaoyangjian724的专栏 1757

C++ 操作重载与类型转换 《C++Primer》第14章 读书笔记

1、基本概念 和 限制条件 只有重载的函数调用运算符operator()能有默认实参,其他重载运算符不能有默认实参。 一个重载的运算符,至少含有一个类类型的参数。 可被重载的运算符: 一般不重载&& || , &这几个运算符 返回值类型一般与内置版本兼容: 逻辑和关系运算符返回bool 算术运算符返回类类型的值 赋值运算符 和 复合运算符 返回左侧运算对象的引用 若一个运算符是成员函数,则他的左侧运算对象绑定到隐式的this指针上。这就是为什么后面重载&lt

m0_51551385的博客 947

在 IW31 录入班次与当班负责人,并让 IW38 列表同步显示:基于 IWO10018 + IWOC0004 的一套可落地增强方案

摘要 本文详细介绍了在SAP PM模块中实现工厂设备维护订单增强的完整方案,重点解决两个核心需求:在订单创建时新增班次负责人和班次字段,并在订单列表中直接显示这些信息。文章从需求分析、技术设计到具体实现步骤进行了系统阐述。 关键实现步骤包括: 通过CI_AUFK结构扩展AUFK表,确保字段持久化存储 使用IWO10018增强在IW31/IW32/IW33事务中添加输入界面 通过IWOC0004增强在IW38订单列表中显示新增字段 采用优化的数据填充策略提升性能 该方案不仅满足业务需求,还考虑了用户体验和系统

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 183

C++ Primer读书笔记

 C++ Primer读书笔记注:本文转自www.Eachfun.com         (整理说明:本资料是我在网上无意间找到的,读起来感觉不错,但由于原文是每章一个网页的格式,读起来不是很习惯,而且也不方便保存,所以我花了2个多小时的时间将所有网页的内容综合整理了一下,但最后才发现,文章的顺序颠倒了,所以各位如果愿意阅读本文的话,请从后面向前读,每个红色“标题”代表一章,如有不

方健的博客 2941

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

C++ primer 第五版个人笔记 第十四章 重载运算与类型转换

14.1 基本概念 除了重载的函数调用运算符operator()外,其他重载运算符不能含有默认实参; 当一个重载的运算符是成员函数时,this绑定到左侧运算对象,成员运算符函数的(显式)参数数量比运算对象少一个; 对于一个运算符函数来说,它或者是类的成员或者至少含有一个类类型的参数;不能为内置类型的运算对象改变运算符的含义; 有四个符号(+,-,*,&)既是一元运算符也是二元运算符,都能重载,从参数的数量可以推断到底定义的是那种运算符; 重载的运算符的优先级和结合律与对应的内置运算符保持一

Mint2yx4的博客 307

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

c++primer读书笔记

c++全局变量无声明。多次定义会冲突。利用命名空间 c++四种cast操作符的区别 1.static_cast,支持子类指针到父类指针的转换,并根据实际情况调整指针的值,反过来也支持,但会给出编译警告,它作用最类似C风格的“强制转换”,一般来说可以认为它是安全的。 2.dynamic_cast,支持父类指针到子类指针的转换,并根据实际情况调整指针的值,和static_cast不同,反

邢文鹏 Linux 传智播客 1875

【读书笔记:C++ primer plus 第六版 中文版】第11章 使用类

转载请注明出处 本章内容包括: 本章内容包括: 运算符重载 友元函数 重载<<运算符,以便用于输出 状态成员 使用rand()生成随机值 类的自动转换和强制类型转换 类转换函数学习C++的难点之一是需要记住大量的东西,但在拥有丰富的实践经验之前,根本不可能全部记住这些东西.从这种意义上说,学习C++就像学习功能复杂的字处理程序或电子制表程序一样.任何特性都不可怕,但多数人只掌握了哪些经常使用的特性.

enyusmile 1661

[读书笔记] C++Primer (第5版) 第14章重载运算与类型转换

1.重载运算符基本概念: 重载运算函数如果是非成员的,则参数数量与该运算符作用的运算对象一样多。如果是成员函数,则运算符的第一个(左侧)运算对象绑定到隐式的this指针上。 一个运算符函数,它或者是类的成员,或者至少含有一个类类型的参数。当运算符作用于内置类型的运算对象时,我们无法改变该运算符的含义。 只能重载已有的运算符,无权发明新的。优先级和结合律与对应的内置运算符保持一致。 不能被重载的运算符: :: , . ?:* data1+data2; 非成员函数等价的调用为

Jamuterbo的博客 303

《C++ Primer》读书笔记

      拿起《C++ Primer》打算重温下C++,感觉自己大二时学的c++基础还是可以,但那些基础只是c++的皮毛,一直感觉没有领悟到c++的精髓。下面会边读边记录我觉得要特别注意或者是我已经不太熟悉的知识点,写读书笔记主要是为了让自己感觉到一本书没有白读,也为了以后的温习。 第1章 开始 1.读取数量不定的输入数据:while(cin&gt;&gt;value)。 2.编译器无法检...

qq_41598851的博客 284

c++ primer(第五版)笔记 第十四章 重载运算与类型转换

// 重载运算符: 其函数名由operator关键字和定义的运算符号组成 // 其参数数量与该运算符作用的运算对象数量一致 // 对于二元运算符来说,左侧运算对象传递给第一个参数,右侧运算对象传递给第二个参数 // 除 operator() 外,其他重载运算符都不能含有默认实参 // 如果该函数是一个成员函数,则其第一个运算对象绑定到隐式的 this 指针上 // 不能被重载的运算符: //

cook A code 579

《C++ Primer》读书笔记——第六章

6.1.1 在c++中,名字有作用域,对象有生命周期。 局部变量尽在函数的作用域内可见,同时会隐藏外层作用域中同名的其他所有声明。 在所有函数体制外定义的对象存在于程序的整个执行过程中。此类对象在启动时被创建,知道结束才会被销毁。 局部变量的生命周期依赖于定义的方式。 只存在于块执行期间的对象成为自动对象。 形参是一种自动对象。 局部静态变量的生命周期可以贯穿函数调用之后的时间。将局

ize 834

C++ Primer Plus 读书笔记

运算符重载 文章 注意事项及总结 首先,在重载最简单的加号+运算符或减号-运算符时,返回值类型要和所需重载类型一致(此处不返回引用),可以采用类内重载和类外重载两种方式。在重载左移<<或重载右移>>运算符时,只能采用类外重载,并且需要返回ostream类型的引用,从而才能实现类似cout << people << endl;的连续输出。其次在重载递增...

qq_43799957的博客 547

【C++基础】第三十七课:函数重载

对于重载的函数来说,它们应该在形参数量或形参类型上有所不同。⚠️不允许两个函数除了返回类型外其他所有的要素都相同。//错误:与上一个函数相比只有返回类型不同。

qq_34222839的博客 604

C++ Primer读书笔记1(经典收藏)

C++ Primer读书笔记 注:本文转自www.Eachfun.com          (整理说明:本资料是我在网上无意间找到的,读起来感觉不错,但由于原文是每章一个网页的格式,读起来不是很习惯,而且也不方便保存,所以我花了2个多小时的时间将所有网页的内容综合整理了一下,但最后才发现,文章的顺序颠倒了,所以各位如果愿意阅读本文的话,请从后面向前读,每个红色“标题”代表一章,

wangxx2011的专栏 1606

【c++primer】第五版第十四章读书笔记

【c++primer】第五版第十四章读书笔记

qq_51931826的博客 129

《C++ Primer》读书笔记目录

目录:笔记会持续更新,有错误的地方欢迎指正,谢谢!第I部分 C++基础第一章:开始第二章:变量和基本类型-基本内置类型和变量第二章:变量和基本类型-复合类型和const限定符第二章:变量和基本类型-处理类型和自定义数据结构第三章:字符串、向量和数组-标准库类型string第三章:字符串、向量和数组-标准库类型vector第三章:字符串、向量和数组-迭代器介绍第三章:字符串、向量和数组-数组和多维

陈云佳的专栏 1520
上一篇: c++ primer读书笔记-第十三章 复制控制
下一篇: c++ primer读书笔记-第十五章 面向对象编程
__WILL
博客等级 码龄14年 14粉丝 116原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值