C++ 模板类的友元和折叠规则

为模板类声明友元类

有时我们需要A类访问模板类B的私有成员,但是不想其他类访问,就要在模板类B里为A类声明友元。比如我们想要实现一个BlobPtr类,让BlobPtr类成为Blob类的友元,这样BlobPtr类就可以访问Blob类了。对于Blob类的声明和定义在前文已经阐述https://llfc.club/articlepage?id=28Vv7hro3VVMPDepLTlLRLqYJhJ
我们省略Blob类的详细声明,只为它添加友元类BlobPtr类,并且为他添加友元函数operator==

class Blob
{
public:
    typedef T value_type;
    typedef typename std::vector<T>::size_type size_type;
    // T类型的BlobPtr是T类型的Blob的友元类
    friend class BlobPtr<T>;
    //重载==运算符
    friend bool operator==(const Blob<T> &, const Blob<T> &);
};

实现友元类BlobPtr

接下来我们实现友元类BlobPtr,先对其进行声明

template <typename T>
class BlobPtr
{
public:
    BlobPtr() : curr(0) {}
    BlobPtr(Blob<T> &a, size_t sz = 0) : wptr(a.data), curr(sz) {}
    //递增和递减
    BlobPtr &operator++(); //前置运算符
                           // BlobPtr &operator--(); //前置运算符--

    BlobPtr &operator++(int);

private:
    std::shared_ptr<std::vector<T>>
    check(std::size_t, const std::string &) const;
    std::size_t curr; //数组中的当前位置
    //保存一个weak_ptr, 表示底层vector可能被销毁
    std::weak_ptr<std::vector<T>> wptr;
};

在实现其定义,这里只举例实现一部分函数,其余的读者自己实现即可。

template <typename T>
BlobPtr<T> &BlobPtr<T>::operator++()
{
    this->curr++;
    return *this;
}

template <typename T>
BlobPtr<T> &BlobPtr<T>::operator++(int)
{
    BlobPtr &rt = *this;
    this->curr++;
    return rt;
}

对于友元函数operator == 的定义可以按照如下实现

template <typename T>
bool operator==(const Blob<T> &b1, const Blob<T> &b2)
{
    if (b1.size() > b2.size())
    {
        return true;
    }

    if (b1.siz() < b2.size())
    {
        return false;
    }

    for (unsigned int i = 0; i < b1.size(); i++)
    {
        if (b1.data[i] == b2.data[i])
        {
            continue;
        }

        return b1.data[i] > b2.data[i];
    }

    return true;
}

模板类的友元还有一些特殊的用法,如下,读者可以自己体会

template <typename T>
class Pal
{
};

template <typename T>
class Pal2
{
};

class C
{
    // Pal<C>是C类的友元
    friend class Pal<C>;
    //所有类型的Pal2的类都是C的友元
    template <typename T>
    friend class Pal2;
};

// c2本身是一个模板类
template <typename T>
class C2
{
    //和C2同类型的Pal是C2的所有实例友元
    friend class Pal<T>;
    // Pal2的所有实例都是C2的所有实例友元
    template <typename X>
    friend class Pal2;
    // Pal3是一个普通类,他是C2的所有实例的友元
    friend class Pal3;
};

定义模板类别名

我们可以通过typedef和using等方式为一个模板类定义别名

template <typename Type>
class Bar
{
    //将访问权限授予用来实例化Bar的类型
    friend Type;
};

//定义模板类别名
typedef long long INT64;
//我们可以为实例好的模板类定义别名
typedef Bar<int> mytype;
// C11 可以为模板类定义别名
template <typename T>
using twin = pair<T, T>;
// authors 是一个pair<string, string>
twin<string> authors;
// infos 是一个pair<int, int>类型
twin<int> infos;
template <typename T>
using partNo = pair<T, unsigned>;
// books是pair<string, unsigned>类型
partNo<string> books;

类模板的静态成员

对于类模板的静态成员,其初始化要放在声明的.h文件中。

//类模板的static成员
template <typename T>
class Foo
{
public:
    static std::size_t count() { return ctr; }

private:
    static std::size_t ctr;
};

//初始化放在和声明所在的同一个.h文件中
template <typename T>
size_t Foo<T>::ctr = 0;

模板类的作用域访问

默认情况下,C++语言假定通过作用域运算符访问的名字不是类型。
因此,如果我们希望使用一个模板类型参数的类型成员,就必须显式告诉编译器该名字是一个类型。
我们通过使用关键字typename来实现这一点:

// 用typename 告知编译器T::value_type是一个类型
template <typename T>
typename T::value_type top(const T &c)
{
    if (!c.empty())
        return c.back();
    else
        return typename T::value_type();
}

我们定义了一个名为top的模板函数,通过T::value_type声明其返回类型,但是C++默认作用域下value_type是一个成员,
所以为了说明value_type是一个类型就需要用typename关键字做声明。

通用的函数对象

我们可以通过模板类实现通用的仿函数,也就是实现通用的函数对象,我们先实现一个DebugDelete类,用来删除各种类型的指针对象

//函数对象,给指定类型的指针执行析构
class DebugDelete
{
public:
    DebugDelete(std::ostream &s = std::cerr) : os(s) {}
    //我们定义一个仿函数,参数是T*类型
    template <typename T>
    void operator()(T *p) const
    {
        os << "deleting unique_str" << std::endl;
        delete p;
    }

private:
    std::ostream &os;
};

DebugDelete构造函数接纳一个输出流,用来在operator()调用时输出删除信息
接下来我们实现一个测试函数,用来说明DebugDelete的用法

void use_debugdel()
{
    double *p = new double;
    DebugDelete d;
    //调用DebugDelete的仿函数,delete p
    d(p);
    //析构多种类型
    int *np = new int;
    //构造DebugDelete对象后调用仿函数析构np
    DebugDelete()(np);
    //作为删除器析构智能指针
    // p 被delete时会执行DebugDelete的仿函数进行析构
    unique_ptr<int, DebugDelete> p3(new int, DebugDelete());
    // 用DebugDelete 的仿函数析构string的指针
    unique_ptr<string, DebugDelete> sp(new string, DebugDelete());
}

可以看出DebugDelete可以用来给智能指针作删除器用。

尾置类型的推断

C11新标准中提出了尾置类型推断

// func接受了一个int类型的实参,返回了一个指针,该指针指向一个含有10个整数的数组
auto func(int i) -> int (*)[10];

利用这个特性,我们可以用在模板函数中,同样实现一个尾置类型推断函数

//推断返回类型,通过尾置返回允许我们在参数列表之后的声明返回类型
template <typename It>
auto fcnrf(It beg, It end) -> decltype(*beg)
{
    //处理序列
    //返回迭代器beg指向的元素的引用
    return *beg;
}

fcnrf的返回类型时It指向元素的解引用(*beg)类型,通过decltype类型推断给出返回的类型。
我们也可以实现一个返回值类型的函数,去掉引用类型。

// remove_reference 是一个模板
// remove_reference<decltype(*beg)>::type
// type的类型就是beg指向元素的类型
// remove_reference<int&>::type type就是int
// remove_reference<string&>::type type就是string

template <typename It>
auto fcncp(It beg, It end) -> remove_reference<decltype(*beg)>
{
    //返回迭代器beg指向元素的copy
    return *beg;
}

引用折叠规则

我们可以用模板定义一个左值引用

//接受左值引用的模板函数
template <typename T>
void f1(T &t)
{
}

当我们用模板类型定义一个右值引用时,传递给该类型的实参类型,会根据C++标准进行折叠。
我们先声明一个右值引用的模板函数

//接受右值引用的模板函数
template <typename T>
void f2(T &&t)
{
}

如果我们调用f2(42), T就被推断为int
int i = 100; f2(i) T就被推断为int& 进行参数展开参数就变为int& &&
折叠后就变为int &
所以我们可以做如下归纳:
当模板函数的实参是一个T类型的右值引用
1 传递给该参数的实参是一个右值时, T就是该右值类型
2 传递给该参数的实参是一个左值时, T就是该左值引用类型。

//折叠规则
//X&& ,X&&& 都会被折叠为X&
//X&& && 会被折叠为X&&
所以根据这个规律,我们可以实现一个类似于stl的move操作

template<typename T>
typename remove_reference<T>::type && my_move(T&& t){
    return static_cast<typename remove_reference<T>::type &&>(t);
}

如果我们在函数中作如下调用

void use_tempmove()
{
    int i = 100;
    my_move(i);
    //推断规则
    /*
    1  T被推断为int &
    2  remove_reference<int &>的type成员是int
    3  my_move 的返回类型是int&&
    4  推断t类型为int& && 通过折叠规则t为int&类型
    5  最后这个表达式变为 int && my_move(int &t)
    */

    auto rb = my_move(43);
    //推断规则
    /*
    1  T被推断为int
    2  remove_reference<int>的type成员是int
    3  my_move 的返回类型为int&&
    4  my_move 的参数t类型为int &&
    5  最后这个表达式变为 int && my_move(int && t)
    */
}

总结

这篇文章介绍了模板参数类型的折叠规则和友元类的声明和使用。
视频链接https://www.bilibili.com/video/BV1cF41177hK?vd_source=8be9e83424c2ed2c9b2a3ed1d01385e9
源码链接 https://gitee.com/secondtonone1/cpplearn

热门评论

热门文章

  1. C++ 类的继承封装和多态

    喜欢(588) 浏览(1271)
  2. Linux环境搭建和编码

    喜欢(594) 浏览(2009)
  3. 解密定时器的实现细节

    喜欢(566) 浏览(1143)
  4. windows环境搭建和vscode配置

    喜欢(587) 浏览(1290)
  5. slice介绍和使用

    喜欢(521) 浏览(1297)

最新评论

  1. 面试题汇总(一) secondtonone1:看到网络上经常提问的go的问题,做了一下汇总,结合自己的经验给出的答案,如有纰漏,望指正批评。
  2. slice介绍和使用 恋恋风辰:切片作为引用类型极大的提高了数据传递的效率和性能,但也要注意切片的浅拷贝隐患,算是一把双刃剑,这世间的常态就是在两极之间寻求一种稳定。
  3. Linux环境搭建和编码 恋恋风辰:Linux环境下go的安装比较简单,可以不用设置GOPATH环境变量,后期我们学习go mod 之后就拜托了go文件目录的限制了。
  4. 构造函数 secondtonone1:构造函数是类的基础知识,要着重掌握
  5. interface应用 secondtonone1:interface是万能类型,但是使用时要转换为实际类型来使用。interface丰富了go的多态特性,也降低了传统面向对象语言的耦合性。

个人公众号

个人微博