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

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中迭代器介紹

迭代器提供對一個容器中的對象的訪問方法，並且定義了容器中對象的範圍
自我感覺不能很好的用文字表述出來，所以直接把膠片放上，便於以後回憶

重點注意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;
};

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

1. conversion function, 轉換函數

2. non-explicit-one-argument ctor

3. pointer-like classes 行爲像指針的類

典型應用：1. 智能指針

典型應用：2. 迭代器

4. function-like classes 像函數的類(仿函數)

5. template 模板

典型應用：1. function template 函數模板

典型應用：2. member template 函數模板（留坑）

6. Specialization，模板特化

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

個數的偏特化

範圍上的偏

8. template template parameter，模板模板參數

# 操作系統實驗報告：ucore-lab1

WFP TreeView使用及注意事項

[Boolan] C++第五週重載const，new，delete

[Boolan] C++第四周 homework 虛函數表與內存對齊

[Boolan] C++第九周 STL 泛型編程（三）

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

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

1. conversion function, 轉換函數

2. non-explicit-one-argument ctor

3. pointer-like classes 行爲像指針的類

典型應用：1. 智能指針

典型應用：2. 迭代器

4. function-like classes 像函數的類(仿函數)

5. template 模板

典型應用：1. function template 函數模板

典型應用：2. member template 函數模板（留坑）

6. Specialization， 模板特化

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

個數的偏特化

範圍上的偏

8. template template parameter， 模板模板參數

6. Specialization，模板特化

8. template template parameter，模板模板參數