[BoolanC++微专业] Week4笔记

最新推荐文章于 2024-07-10 22:49:54 发布

干冰之剑0037

最新推荐文章于 2024-07-10 22:49:54 发布

阅读量338

点赞数

分类专栏： boolen C++ 文章标签： c++

本文链接：https://blog.csdn.net/qq_33988516/article/details/56479082

版权

boolen 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

C++

4 篇文章 0 订阅

订阅专栏

一、conversion function;
一开始想在网上找一找关于conversion function的信息，但是只有在MSDN上找到只言片语：
https://msdn.microsoft.com/en-us/library/5s5sk305.aspx
This content has been relocated. For information about conversion functions, see User-Defined Type Conversions (C++).
好吧巨硬你赢了。
还是从侯捷老师的程序开始讲起吧。

class Fraction
{
public:
    Fraction(int num, int den = 1):m_numerator(num), m_denominator(den) {}
    operator double() const
    {
        return (double) (m_numberator / m_denominator);
    }
private:
    int m_numerator;
    int m_denominator;
}

当程序运行如下时：

Fraction f(3,5);
double d = 4 + f;

如果没有定义

friend Fraction operator+(const double &lhs,const Fraction &rhs)

那么在一般意义上，+号会报错。
但是在类Fraction中有：

operator double() const{}

这个函数，意味着它可以在需要的时候，将类Fraction的实例转double。

从另一个方向来说：

class Fraction
{
public:
    Fraction(int num, int den = 1):m_numerator(num), m_denominator(den) {}
    Fraction operator+(const Fraction &rhs){}
private:
    int m_numerator;
    int m_denominator;
}

此时运行

Fraction d2 = f + 4;

会调用构造函数，将4转化为Fraction(4,1)，然后调用Fracion operator+。

然而当Fraction(),operator+,operator double()同时存在时，再次调用就会出现二义性，编译器无法分辨到底应该调用哪一个函数。但是这几个函数都是有必要存在的，怎么办？
此时可以在 Fraction()前加上explicit 修饰词，此时，此构造函数不可以用于隐式地创建Fraction对象。
关键字只对一个实参的构造函数有效，需要多个构造函数不能用于执行隐式转换，所以无需将这些构造函数指定为explicit的。
当我们用explicit关键字声明构造函数时，它将只能以直接初始化的形式使用，而且编译器不会在自动转换中使用该构造函数。

二、智能指针:
智能指针类似于vector，它也是一个模板，让我们创建一个只能指针时，也必须提供额外的信息—-指针指向的类型。默认初始化的智能指针中保存着一个空指针。
由于智能指针只是一个模板类，所以需要重载’*’与’->’来达到与指针相似的用法，

T& operator*() const{}
T& operator->() const {}

关于*运算符的重载，大家应该都没有什么异议，关于->运算符重载大家肯定由疑问。
比如程序如下：

shared_ptr<Foo> sp (new Foo);
sp->method();

此时由于(sp->)method()调用运算符重载，那么不会变成(ptr)methon()这种类型么？
群友在
https://www.ibm.com/support/knowledgecenter/SS2LWA_12.1.0/com.ibm.xlcpp121.bg.doc/language_ref/cplr329.html
找到了解答。

The statement x->f() is interpreted as (x.operator->())->f().

The operator-> is used (often in conjunction with the
pointer-dereference operator) to implement “smart pointers.” These
pointers are objects that behave like normal pointers except they
perform other tasks when you access an object through them, such as
automatic object deletion (either when the pointer is destroyed, or
the pointer is used to point to another object), or reference counting
(counting the number of smart pointers that point to the same object,
then automatically deleting the object when that count reaches zero).

这个是C++中约定俗称的一种语法，这个锅主要还是要甩给’.’运算符无法进行重载，所以给’->’一个特殊的重载形式。

三、迭代器：

An iterator is any object that, pointing to some element in a range of
elements (such as an array or a container), has the ability to iterate
through the elements of that range using a set of operators (with at
least the increment (++) and dereference (*) operators).

The most obvious form of iterator is a pointer: A pointer can point to
elements in an array, and can iterate through them using the increment
operator (++). But other kinds of iterators are possible. For example,
each container type (such as a list) has a specific iterator type
designed to iterate through its elements.

Notice that while a pointer is a form of iterator, not all iterators
have the same functionality of pointers; Depending on the properties
supported by iterators, they are classified into five different

迭代器是一个类，但是它归根究底，还是用指针实现的。比较简单，并没有什么好讲的。

四、仿函数：
其实它的本质就是一个重载了（）运算符的类。

// this is a functor
struct add_x {
  add_x(int x) : x(x) {}
  int operator()(int y) const { return x + y; }

private:
  int x;
};

// Now you can use it like this:
add_x add42(42); // create an instance of the functor class
int i = add42(8); // and "call" it
assert(i == 50); // and it added 42 to its argument

std::vector<int> in; // assume this contains a bunch of values)
std::vector<int> out(in.size());
// Pass a functor to std::transform, which calls the functor on every element 
// in the input sequence, and stores the result to the output sequence
std::transform(in.begin(), in.end(), out.begin(), add_x(1)); 
assert(out[i] == in[i] + 1); // for all i