[Boolan] C++第四周 C++面向对象（下）

最新推荐文章于 2022-07-27 12:52:37 发布

小小初行者

最新推荐文章于 2022-07-27 12:52:37 发布

阅读量403

点赞数

分类专栏： C/C++学习笔记文章标签： template 偏特化

本文链接：https://blog.csdn.net/a312024054/article/details/54997592

版权

C/C++学习笔记专栏收录该内容

23 篇文章 1 订阅

订阅专栏

1. conversion function, 转换函数

转换函数，用作类型转换，编译器可以自动调用，当然也可以显示调用，C风格的(type)value, C++风格的static_cast<type>value 都是可以的
需要注意的是如果类已经有转换函数，就不需要在写这个类与要转换的类的运算符重载了，因为会出现二义性，例如代码注释的部分

#include <iostream>
#include <stdio.h>

class Fraction
{
public:
    Fraction(int num, int den=1)
        :m_numerator(num), m_denominator(den)
    {   }

    operator double() const {
        printf("-------operator double() const-----\n");
        return (double)(m_numerator/m_denominator);
    }
    //friend double operator +(double left, Fraction tmp);
private:
    int m_numerator;
    int m_denominator;
};

/*
double operator + (double left, Fraction tmp)
{
    return left + tmp.m_numerator/tmp.m_denominator;
} 
*/
int main(int argc, char *argv[])
{
    Fraction f(3,5);

    double d = 4 + f;
    double r = (double)f;
    double s = static_cast<double>(f);

    return 0;
}


operator double() const
operator double() const
operator double() const

2. non-explicit-one-argument ctor

没有指定明确调用的单一参数的构造函数

以下代码为例

#include <iostream>
#include <stdio.h>

class Fraction
{
public:
    Fraction(int num, int den=1)
        :m_numerator(num), m_denominator(den)   { 
        printf("num=%d, den=%d\n", num, den);   
    }

    Fraction operator+(const Fraction &f)   {
        printf("Fraction operator+(const Fraction &f)\n");
        //TODO
        return Fraction(0); //添0是为了编译通过 并不是正确的结果
    }

private:
    int m_numerator;
    int m_denominator;
};

int main(int argc, char *argv[])
{
    Fraction f(3,5);
    Fraction d = f + 4 ;
    return 0;
}

////////////////
num=3, den=5
num=4, den=1
Fraction operator+(const Fraction &f)
num=0, den=1

Fraction的构造函数有两个参数，但是有一个是默认参数，所以可以等同是单一参数的构造函数，
    编译器在执行`f+7`的时候，会先想办法
    首先匹配到重载的`Fraction operator+(const Fraction &f)`，但是只适用于`Fraction`类之间运算，然后编译器就试着把`4`转换位`Fraction`类，
    于是发现`Fraction`有一个`non-explicit-one-argument ctor`，并且参数刚好是`int`类型，所以就进行了隐示转换，把`4`转换成`Fraction`类，
    之后在调用`Fraction operator+(const Fraction &f)`,返回一个新的`Fraction`.

能够把4转换成Fraction类，是因为Fraction的构造函数没有声明explicit，即该构造函数只能显示调用，不能进行隐示调用

    operator double() const {
        return (double)(m_numerator/m_denominator);
    }
此时添加Fraction转double的转化函数， 编译器就不会通过了，因为`f+4`既可以使用操作符重载，也可以使用隐式类型转换，具有二义性ambiguous

如果此时把Fraction的构造声明为explicit，因为Fraction的构造不能隐式调用，还会报错：cannot convert from 'double' to 'class Fraction'

3. pointer-like classes 行为像指针的类

典型应用：1. 智能指针

只能指针的基本功能应该重载 * 和 -> 这两个操作符，和相应的构造析构函数

#include <iostream>
struct Foo
{
    void method()
    {
        printf("---------------------\n");
    }
    int value;
};

template <class T>
class shared_ptr
{
public:
    T& operator*() const {
        return *px;
    }

    T* operator-> () const {
        return px;
    }

    shared_ptr(T* p) : px(p) {}

    ~shared_ptr(){ delete px; }
private:
    T*      px;
};

void func()
{
    shared_ptr<Foo> pFoo(new Foo);

    Foo f = *pFoo;
    pFoo->method();
}

int main(int argc, char *argv[])
{
    func();
    return 0;
}

典型应用：2. 迭代器

参考链接：C++学习篇——C++ STL中迭代器介绍

迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围
自我感觉不能很好的用文字表述出来，所以直接把胶片放上，便于以后回忆

pointer-like_iterater_1

pointer-like_iterater_2

重点注意operator->操作符重载，为了能够实现 ite->mothed(),这样调用，所以ite->要返回数据的指针，所以是先operator*()，获取到数值，然后，然后再&获取指针

4. function-like classes 像函数的类(仿函数)

参考链接:C++标准库—pair用法及实现
仿函数就是类重载了() 操作符
下列代码中简单的实现了C++的pair，其中MySelect1st， MySelect2nd就是仿函数
写的过程中熟悉了pair的first_type,second_type 还有vaue_type的用法

#include <iostream>

template <class T1, class T2>
struct MyPair{
    typedef T1 first_type;  
    typedef T2 second_type; 

    typedef MyPair<T1,T2> value_type;

    MyPair() 
        : first(T1()), second(T2()) 
    {}
    MyPair(const T1& a, const T2& b)
        :first(a), second(b)
    {}

    T1 first;
    T2 second;
};

template <class Pair>
struct MySelect1st{
    const typename Pair::first_type &
        operator() (const Pair& x) const 
    {
        return x.first;
    }
};

template <class Pair>
struct MySelect2nd{
    const typename Pair::second_type &
        operator() (const Pair& x) const 
    {
        return x.second;
    }
};

int main(int argc, char *argv[])
{
    MyPair<int, double> p(10, 20.3);

    MySelect1st<MyPair<int, double> > s1;
    MySelect2nd<MyPair<int, double> > s2;

    std::cout << "first : " << s1(p) << std::endl;
    std::cout << "second : " << s2(p) << std::endl;

    return 0;
}

5. template 模板

典型应用：1. function template 函数模板

与class template不同，function template在使用的时候并不需要指定类型，而是编译器会对function template进行实参推导argument deduction, 确定类型

#include <iostream>

template <class T>
inline 
const T& MyMin(const T&a, const T&b)
{
    return b < a ? b : a;
}

int main(int argc, char *argv[])
{
    int a = 10, b = 20;
    std::cout << MyMin(a,b) << std::endl;

    return 0;
}

典型应用：2. member template 函数模板（留坑）

简单点来说就是类成员某些参数需要模板
下面以智能指针举例
但是我没有想明白在这个例子中这么做的必要性，因为就算没有这个模板的拷贝构造，这个也是可以的，因为父类指针可以指向子类对象，  留坑，等想到更好例子在进行更新

#include <iostream>

template <typename T>
class shared_ptr
{
public:
    T& operator*() const {
        return *_px;
    }

    T* operator-> () const {
        return _px;
    }

    explicit shared_ptr(T* p) : _px(p) { std::cout << "shared_ptr(T* p)" <<std::endl;}

    template <typename _Tp1>
    explicit shared_ptr(_Tp1* p)
    :_px(p)
    {std::cout << "shared_ptr(_Tp1* p)" <<std::endl;    }

    ~shared_ptr(){ delete _px; }
private:
    T*      _px;
};

class A
{
    //..
};

class B : public A 
{
    //..
};

int main(int argc, char *argv[])
{
    B * pa = new B;
    shared_ptr<A> pSA(new B);

    return 0;
}

6. Specialization，模板特化

就是在一个模板类里面，为某几种已知的类进行单独处理
下面以函数模板举例，对int进行模板特化

#include <iostream>

template <class T>
inline 
const T& MyMin(const T&a, const T&b)
{
    std::cout << "const T& MyMin(const T&a, const T&b)" <<std::endl;
    return b < a ? b : a;
}

template <>
inline 
const int& MyMin<int>(const int&a, const int&b)
{
    std::cout << "const int& MyMin<int>(const int&a, const int&b)" <<std::endl;
    return b < a ? b : a;
}

int main(int argc, char *argv[])
{
    std::cout << MyMin(10,20) << std::endl;
    std::cout << MyMin(100.2, 200.3) << std::endl;;

    return 0;
}


const int& MyMin<int>(const int&a, const int&b)
10
const T& MyMin(const T&a, const T&b)
100.2

7. partial Specialization, 模板偏特化/局部特化

参考链接：模板的全特化与偏特化
偏特化分为两种：个数上的偏特化和范围上的偏特化

个数的偏特化

部分模板参数偏特化，在VC6上会编译失败，Qt的C++11是可以的

template <class T1, class T2>
struct MyPair
{
    MyPair(const T1& a, const T2& b)
        :first(a), second(b)
    {}
    T1 first;
    T2 second;
};

template <class T2>
struct MyPair<bool>
{
    MyPair(const bool& a, const T2& b)
        :first(a), second(b)
    {}
    bool first;
    T2 second;
};

范围上的偏

这个主要解决模板指针进行模板的方式，在VC6上会编译失败，Qt的C++11是可以的

template <typename T1>
class C
{
};

template<typename T1>
class C<T1*>
{
};

8. template template parameter，模板模板参数

一个模板定义的template中不是自定义或基础数据类型，而是另一个模板
例如下面例子中，XCLs模板中，有两个typename      
       其中一个是T的模板，基础类型或者自定义类型
       另一个是模板类，这个模板类的只有一个typename，并且他的T和XCLs的第一个typename类型一样
下列代码中给出了实例化这个模板类的展开样子，更有助益理解

#include <iostream>
using namespace std;

template <typename T, template <typename T> class TempClass>
class XCLs
{
private:
    TempClass<T>    c;
};

template <typename T>
using Lst = list<T, allocator<T>>;      //因为list其实有多个模板参数，但是XCLs的第二个模板参数只接受只有一个模板参数的模板类，收益通过 这种方式把list其他参数固化

template <typename T>
class A{
    T a;
};

int main(int argc, char *argv[])
{
    XCLs<string, Lst> mylist;

    XCLs<string, A> myA;
    return 0;
}


///XCLs<string, Lst> mylist ---> 展开
template <string, template <string> class list>
class XCLs
{
private:
    list<string>    c;
};

小小初行者

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[Boolan] C++第四周 C++面向对象（下）

1. conversion function, 转换函数转换函数，用作类型转换，编译器可以自动调用，当然也可以显示调用，C风格的(type)value, C++风格的static_cast<type>value 都是可以的需要注意的是如果类已经有转换函数，就不需要在写这个类与要转换的类的运算符重载了，因为会出现二义性，例如代码注释的部分#include <iostream>#include <
复制链接

扫一扫