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

Posted on | In

为模板类声明友元类

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

1
2
3
4
5
6
7
8
9
10
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,先对其进行声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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;
};

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 == 的定义可以按照如下实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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;
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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等方式为一个模板类定义别名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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文件中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//类模板的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来实现这一点：

1
2
3
4
5
6
7
8
9
// 用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类，用来删除各种类型的指针对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//函数对象，给指定类型的指针执行析构
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的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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新标准中提出了尾置类型推断

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
// 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;
}

引用折叠规则

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

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

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

1
2
3
4
5
//接受右值引用的模板函数
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操作

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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