C++ Primer 学习笔记 第十六章模板与泛型编程

最新推荐文章于 2024-08-13 13:28:29 发布
最新推荐文章于 2024-08-13 13:28:29 发布
阅读量469 收藏
点赞数
文章标签： c++ c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HELLOWORLD2424/article/details/123042210
版权

578 定义模板

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;



template <typename T>

int compare(const T &v1, const T &v2){
    if(v1<v2) return -1;
    if(v2<v1) return 1;
    return 0;
}

int main(){
	cout << compare(1, 0) << endl; // 1
	vector<int> vec1{7, 2, 3}, vec2{4, 5, 6};
    cout << compare(vec1, vec2) << endl; // 1


}

580 非类型模板参数

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;



template<unsigned N, unsigned M>
int compare(const char (&p1)[N], const char (&p2)[M]){
    return strcmp(p1, p2);
}


int main(){
    // only compare the first letter
    cout << compare("hi", "mom") << endl; // -1


}

581 编写类型无关的代码

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Blob{
public:
    typedef T value_type;
    typedef typename vector<T>::size_type size_type;
    Blob()=default;
    Blob(initializer_list<T> il){}
    size_type size() const {return data->size();}
    bool empty() const {return data->empty();}
    void push_back(const T &t){data->push_back(t);}
    void pop_back(){}
    T& back(){}
    T& operator[](size_type i){}
private:
    shared_ptr<vector<T>> data;
    void check(size_type i,const string &msg) const{}

};

int main(){
    Blob<int> ia;
    Blob<int> ia2={1, 2, 3, 4};

}

584 实例化模板类

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Blob{
public:
    typedef T value_type;
    typedef typename vector<T>::size_type size_type;
    Blob()=default;
    Blob(initializer_list<T> il){}
    size_type size() const {return data->size();}
    bool empty() const {return data->empty();}
    void push_back(const T &t){data->push_back(t);}
    void pop_back(){}
    T& back(){}
    T& operator[](size_type i){}
private:
    shared_ptr<vector<T>> data;
    void check(size_type i,const string &msg) const{}

};

int main(){
    Blob<int> ia;
    Blob<int> ia2={1, 2, 3, 4};
    
    Blob<string> names;
    Blob<double> prices;
    return 0;

}

586 模板类的成员函数以及构造函数

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Blob{
public:
    typedef T value_type;
    typedef typename vector<T>::size_type size_type;
    Blob();
    Blob(initializer_list<T> il);
    size_type size() const {return data->size();}
    bool empty() const {return data->empty();}
    void push_back(const T &&t){data->push_back(move(t));}
    void pop_back();
    T& back();
    T& operator[](size_type i);
private:
    shared_ptr<vector<T>> data;
    void check(size_type i,const string &msg) const;

};

template <typename T>
void Blob<T>::check(size_type i, const string &msg) const {
    if(i>=data->size()){
        throw out_of_range(msg);
    }
}

template <typename T>
T & Blob<T>::back() {
    check(0, "back on empty Blob");
    return data->back();
}

template <typename T>
T & Blob<T>::operator[](size_type i) {
    check(i, "index out of range");
    return (*data)[i];
}

template <typename T> void Blob<T>::pop_back() {
    check(0, "empty blob");
    data->pop_back();
}

template <typename T>
Blob<T>::Blob():data(make_shared<vector<T>>()){

}

template <typename T>
Blob<T>::Blob(initializer_list<T> il):data(make_shared<vector<T>>(il)) {

}


int main(){
    Blob<int> ia;
    Blob<int> ia2={1, 2, 3, 4};

    Blob<string> articles = {"a", "an", "the"};

    Blob<int> squares = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    for (size_t i=0;i!=squares.size();++i){
        squares[i] = i*i;
    }


    return 0;

}

588

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Blob{
public:
    typedef T value_type;
    typedef typename vector<T>::size_type size_type;
    Blob();
    Blob(initializer_list<T> il);
    size_type size() const {return data->size();}
    bool empty() const {return data->empty();}
    void push_back(const T &&t){data->push_back(move(t));}
    void pop_back();
    T& back();
    T& operator[](size_type i);
    shared_ptr<vector<T>> data;
private:
    void check(size_type i,const string &msg) const;

};

template <typename T>
void Blob<T>::check(size_type i, const string &msg) const {
    if(i>=data->size()){
        throw out_of_range(msg);
    }
}

template <typename T>
T & Blob<T>::back() {
    check(0, "back on empty Blob");
    return data->back();
}

template <typename T>
T & Blob<T>::operator[](size_type i) {
    check(i, "index out of range");
    return (*data)[i];
}

template <typename T> void Blob<T>::pop_back() {
    check(0, "empty blob");
    data->pop_back();
}

template <typename T>
Blob<T>::Blob():data(make_shared<vector<T>>()){

}

template <typename T>
Blob<T>::Blob(initializer_list<T> il):data(make_shared<vector<T>>(il)) {

}


template <typename T> class BlobPtr{
public:
    BlobPtr():curr(0){}
    BlobPtr(Blob<T> &a, size_t sz=0):wptr(a.data),curr(sz){}
    T& operator*() const{
        auto p = check(curr, "dereference past end");
        return (*p)[curr];
    }

    BlobPtr& operator++(int);
//    or
//    BlobPtr<T>& operator++(int);
    BlobPtr& operator--();
private:
    shared_ptr<vector<T>> check(size_t, string&) const;
    weak_ptr<vector<T>> wptr;
    size_t curr;
};

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


int main(){
    Blob<int> blob{1, 2, 3, 4};
    BlobPtr<int> blob_ptr(blob, 0);
    return 0;

}

589 模板类与友元

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename> class BlobPtr;
template <typename> class Blob;
template <typename T>
bool operator==(const Blob<T>&, const Blob<T>&);

template <typename T> class Blob{
    friend class BlobPtr<T>;
    friend bool operator==<T>(const Blob<T>&, const Blob<T>&);
public:
    typedef T value_type;
    typedef typename vector<T>::size_type size_type;
    Blob();
    Blob(initializer_list<T> il);
    size_type size() const {return data->size();}
    bool empty() const {return data->empty();}
    void push_back(const T &&t){data->push_back(move(t));}
    void pop_back();
    T& back();
    T& operator[](size_type i);

private:
    shared_ptr<vector<T>> data;
    void check(size_type i,const string &msg) const;

};

template <typename T>
void Blob<T>::check(size_type i, const string &msg) const {
    if(i>=data->size()){
        throw out_of_range(msg);
    }
}

template <typename T>
T & Blob<T>::back() {
    check(0, "back on empty Blob");
    return data->back();
}

template <typename T>
T & Blob<T>::operator[](size_type i) {
    check(i, "index out of range");
    return (*data)[i];
}

template <typename T> void Blob<T>::pop_back() {
    check(0, "empty blob");
    data->pop_back();
}

template <typename T>
Blob<T>::Blob():data(make_shared<vector<T>>()){

}

template <typename T>
Blob<T>::Blob(initializer_list<T> il):data(make_shared<vector<T>>(il)) {

}


template <typename T> class BlobPtr{
public:
    BlobPtr():curr(0){}
    BlobPtr(Blob<T> &a, size_t sz=0):wptr(a.data),curr(sz){}
    T& operator*() const{
        auto p = check(curr, "dereference past end");
        return (*p)[curr];
    }

    BlobPtr& operator++(int);
//    or
//    BlobPtr<T>& operator++(int);
    BlobPtr& operator--();
private:
    shared_ptr<vector<T>> check(size_t, string) const;
    weak_ptr<vector<T>> wptr;
    size_t curr;
};

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

template<typename T>
shared_ptr<vector<T>> BlobPtr<T>::check(size_t i, string msg) const {
    auto ret = wptr.lock();
    if(!ret){
        throw runtime_error("unbound strblobptr");
    }
    if (i>=ret->size())
        throw out_of_range(msg);
    return ret;
}


int main(){
    Blob<int> blob{1, 2, 3, 4};
    BlobPtr<int> blob_ptr(blob, 0);

    cout << *blob_ptr << endl;
    blob_ptr++;
    cout << *blob_ptr << endl;

    return 0;

}

589 通用和特定模板友好关系

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Pal;
class C{
    friend class Pal<C>;
    template<class T> friend class Pal2;
};

template <typename T> class C2{
    friend class Pal<T>;
    template<class X> friend class Pal2;
    friend class Pal3;
};


int main(){
    return 0;

}

590 为模板类起别名

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Blob{
public:
    Blob()=default;

};

typedef Blob<string> StrBlob;

int main(){
    return 0;

}

590 模板类的静态成员

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Foo{
public:
    static size_t count() {return  ctr;}

private:
    static size_t ctr;
};

template <typename T>
size_t Foo<T>::ctr=0;


int main(){

    Foo<int> fi;
    auto ct = Foo<int>::count();
    ct = fi.count();
    // error 哪个模板实例的count?
//    ct = Foo::count();
    return 0;

}

593 模板参数以及模板的声明与定义

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename Foo> Foo calc(const Foo& a, const Foo&b){
    
}

template <typename T> int compare(const T&, const T&);
template <typename T> class Blob;

template <typename T> T calc(const T&, const T&);
template <typename U> U calc(const U&, const U&);

template <typename Type>
Type calc2(const Type& a, const Type& b){};


int main(){

    return 0;

}

593 使用类的类型成员

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T>
typename T::value_type top(const T& c){
    if (!c.empty())
        return c.back();
    else
        return typename T::value_type();
}


int main(){

    return 0;

}

594 默认模板实参

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T, typename F=less<T>>
int compare(const T &v1, const T &v2, F f=F()){
    if (f(v1, v2)) return -1;
    if (f(v2, v1)) return 1;
    return 0;
}


int main(){
    bool i = compare(0, 42);
    
    return 0;

}

595

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <class T=int> class Numbers{
public:
    Numbers(T v=0):val(v){}

private:
    T val;
};

int main(){
    Numbers<long double> lots_of_precision;
    Numbers<> average_precision;

}

595 普通的类成员模板

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


class DebugDelete{
public:
    DebugDelete(ostream &s=cerr):os(s){}

    template<typename T> void operator()(T *p) const{
        os << "deleting unique_ptr" << endl;
        delete p;
    }
private:
    ostream &os;
};
// using as deletor of unique_ptr
unique_ptr<int, DebugDelete> p(new int, DebugDelete());


int main(){
    double *p = new double;
    DebugDelete d;
    d(p);

    int *ip = new int(32);
    DebugDelete()(ip);
}

596 类成员的模板

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Blob{
    template<typename It> Blob(It b, It e);

private:
    shared_ptr<vector<T>> data;
};

template <typename T>
template <typename It>
Blob<T>::Blob(It b, It e):data(make_shared<vector<T>>(b, e)) {}

int main(){

}

597 实例化类成员模板

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> class Blob{
public:
    template<typename It> Blob(It b, It e);

private:
    shared_ptr<vector<T>> data;
};

template <typename T>
template <typename It>
Blob<T>::Blob(It b, It e):data(make_shared<vector<T>>(b, e)) {}

int main(){
    int ia[] = {0, 1, 2, 3, 4};
    vector<long> vi = {0, 1, 2, 3, 4, 5, 6};
    list<const char *> w = {"now", "is", "the", "time"};
    
    Blob<int> a1(begin(ia), end(ia));
    Blob<int> a2(vi.begin(), vi.end());
    Blob<string> a3(w.begin(), w.end());    

}

601 类型转换与模板类型参数

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> T fobj(T t1, T t2){
    return t1;
}
template <typename T> T fref(const T& t1, const T& t2){
    return t1;
}



int main(){
    string s1("a value");
    const string s2("another value");
    fobj(s1, s2);
    fref(s1, s2);

    int a[10], b[42];
    fobj(a, b);
    // reference will not convert to pointer
    // fref(a, b);

}

602 推断形参类型时候需要与模板定义中的关系一样

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename A, typename B>
int flexibleCompare(const A& v1, const B& v2){
    if (v1<v2) return -1;
    if (v2<v1) return 1;
    return 0;
}


int main(){
    long lng=2048;
    cout << flexibleCompare(lng, 1024) << endl;

}

602 普通实参的类型转换

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> ostream &print(ostream &os, const T& obj){
    return os << obj << endl;
}


int main(){
    print(cout,42);
    ofstream f("output");
    print(f, 10); // create output and write 10 inside

}

604 显式的指定模板实参类型

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T1, typename T2, typename T3>
T3 alternative_sum(T2 t2, T1 t1){
    return t2;
}


int main(){
    int i = 1; long lng = 2;
    // can not deduce T3
//    auto val3 = alternative_sum<long long>(i, lng);
    auto val2 = alternative_sum<long long, int, long>(i, lng);
    cout << val2 << endl;

}

604 显式的指定模板实参类型

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T, typename F=less<T>>
int compare(const T &v1, const T &v2, F f=F()){
    if (f(v1, v2)) return -1;
    if (f(v2, v1)) return 1;
    return 0;
}


int main(){
    // error params not match
//    bool i = compare(0, 42.2);
    long lng = 9;
    // 两个参数强制转换成long
    compare<long>(lng, 1024); // long, long
    // 两个参数强制转换成int
    compare<int>(lng, 1024); // int, int
    return 0;

}

604 返回类型根据参数去自动推断

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename It>
auto fcn(It beg, It end) -> decltype(*beg){
    return *beg;
}

template <typename It>
auto fcn2(It beg, It end)->typename remove_reference<decltype(*beg)>::type{
    return *beg;
}

int main(){
    vector<int> v1 = {1, 2, 3, 4, 5};
    vector<string> ca = {"hi", "bye"};

    cout << fcn(v1.begin(), v1.end())<< endl;
    cout << fcn(ca.begin(), ca.end()) << endl;

    cout << fcn2(v1.begin(), v1.end()) << endl;

    return 0;

}

607 函数指针和实参推断

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> int compare(const T&, const T&);
int (*pf1)(const int&, const int&) = compare;

void func(int(*) (const string&, const string&));
void func(int(*) (const int&, const int&));



int main(){
    func(compare<int>);
    
    return 0;

}

608 模板参数左值和右值的问题

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> void f1(T&){};
template <typename T> void f3(T&&){};



int main(){
    int i=1;
    f1(i);
    const int ci = 2;
    f1(ci);
    // error
//    f1(2);
    f3(2);
    return 0;
}

609 接受右值引用模板函数的两种特例

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;

template <typename T>
T fcn(T t){
    return t+1;
}

template <typename T>
void f3(T&& val){
    T t = val; // copy
    t = fcn(t);

    cout << "t: " << t << endl;
    cout << "val: " << val << endl;

    if (val == t){

    }
}


int main(){


    f3(42); // t 43 val 42

    int a =42;
    f3(a);
    cout << "a: " << a << endl; // t 43, val 43 a 43
    return 0;
}

614 引用的转发

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;

template <typename F, typename T1, typename T2>
void flip1(F f, T1 t1, T2 t2){
    f(t2, t1);
}

void f(int v1, int &v2){
    cout << v1 << " " << ++v2 << endl;
}

template <typename F, typename T1, typename T2>
void flip2(F f, T1 &&t1, T2 &&t2){
    f(t2, t1);
}

//void g(int &&i, int &j){
//    cout << i << " " << j << endl;
//}



int main(){
    int a = 42;
    f(42, a);
    cout << a << endl; //43

    a = 42;
    flip1(f, a, 42);
    cout << a << endl;  // 42

    a = 42;
    flip2(f, a, 42);
    cout << a << endl;  // 43

    // error
//    a = 42;
//    flip2(g, a, 42); // 43
//    cout << a << endl;  // 42

    return 0;
}

614 翻转函数的终极版本

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


void g(int &&i, int &j){
    cout << i << " " << ++j << endl;
}

template <typename F, typename T1, typename T2>
void flip(F f, T1 &&t1, T2 &&t2){
    g(std::forward<T2>(t2), std::forward<T1>(t1));
}

int main(){

    int a = 42;
    flip(g, a, 42); 
    cout << a << endl;  // 43
    return 0;
}

616 模板的重载

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> string debug_rep(const T &t){
    ostringstream ret;
    ret << t;
    return ret.str();
}

template <typename T> string debug_rep(T *p){
    ostringstream ret;
    ret << "pointer: " << p;
    if (p){
        ret << " " << debug_rep(*p);
    } else{
        ret << " null pointer";
    }
    return ret.str();
}


int main(){
    string s("hi");
    cout << debug_rep(s) << endl;   // hi 

    cout << debug_rep(&s) << endl; //pointer: 0034F7F4 hi
    return 0;
}

615 优先选择普通函数而非模板

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> string debug_rep(const T &t){
    ostringstream ret;
    ret << t;
    return ret.str();
}

string debug_rep(const string &s){
    return '"' + s + '"';
}





int main(){
    string s("hi");
    cout << debug_rep(s) << endl;   // "hi"
    return 0;
}

619 可变参数模板

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T, typename... Args>
void foo(const T &t, const Args& ... rest);


int main(){
    int i = 0;
    double d = 3.14;
    string s = "how now brown cow";
    foo(i, s, 42, d);
    foo(s, 42, "hi");
    foo("hi");
    return 0;
}

619 确定参数包的大小

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template<typename ... Args>
void g(Args ... args){
    cout << sizeof...(Args) << endl;
    cout << sizeof...(args) << endl;
}


int main(){
    g(1, "gaa", 1.3); //3
    return 0; // 3
}

620 递归调用可变参数模板

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template<typename T>
ostream &print(ostream &os, const T &t){
    return os << t;
}

// recursive calling
template <typename T, typename ... Args>
ostream &print(ostream &os, const T &t, const Args ... rest){
    os << t << ", ";
    return print(os, rest...);
}

int main(){
    print(cout, 1, "gaa", 1.3);
    return 0;
}

622 包的扩展,把参数包里面的每一个参数应用到某个函数中

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template<typename T>
ostream &print(ostream &os, const T &t){
    return os << t;
}

// recursive calling
template <typename T, typename ... Args>
ostream &print(ostream &os, const T &t, const Args ... rest){
    os << t << ", ";
    return print(os, rest...);
}

template <typename T>
string debug_rep(T& t){
    ostringstream ret;
    ret << t + 1;
    return ret.str();
}

template <typename... Args>
ostream &errorMsg(ostream &os, const Args&... rest){
    return print(os, debug_rep(rest)...);
}


int main(){
    errorMsg(cout, 1, 2, 3, 4, 5); // 2, 3, 4, 5, 6
    return 0;
}

624 转发参数包

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template<typename... Args>
void fun(Args&&... args){
    work(std::forward<Args>(args)...);
}


int main(){
    return 0;
}

625 模板的特例化

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> int compare(const T&, const T&){
    cout << "common type" << endl;
    return 1;
}

template<size_t N, size_t M>
int compare(const char (&)[N], const char (&)[M])
{
    cout << "special type" << endl;
    return 0;
}


int main(){
    const char *p1 = "hi", *p2 = "mom";
    compare(p1, p2); // common type
    compare("hi", "mom"); // common type


    return 0;
}

625 函数模板特例化

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> int compare(const T&, const T&){
    cout << "common type" << endl;
    return 1;
}


// 函数模板特例化
template <>
int compare(const char* const &p1, const char* const &p2){
    return 2
}


int main(){
    const char *p1 = "hi", *p2 = "mom";
    compare(p1, p2); // common type
    compare("hi", "mom"); // common type


    return 0;
}

628 类模板部分特例化

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <class T>
struct book{
    typedef T type;
public:
    void debug(){
        cout << "normal version" << endl;
    }
};

template <class T>
struct book<T&>{
    typedef T type;
public:
    void debug(){
        cout << "left reference version" << endl;
    }
};

template <class T>
struct book<T&&>{
    typedef T type;
public:
    void debug(){
        cout << "right reference version" << endl;
    }
};


int main(){
    int i=42;
    int& j = i; 
    book<decltype(42)> a; // normal version
    a.debug();

    book<decltype(j)> b; //left reference version
    b.debug();

    book<decltype(move(i))> c; // right reference version
    c.debug();



    return 0;
}

629 特例化类成员

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T> struct Foo{
    Foo(const T &t):mem(t){}
    void Bar(){
        cout << "normal bar" << endl;
    }
    T mem;
};

template<>
void Foo<int>::Bar() {
    cout << "special bar" << endl;
}


int main(){
    Foo<int> f1(2);
    f1.Bar(); // special bar

    Foo<string> f2("ah");
    f2.Bar(); // normal bar
    return 0;
}

16.63

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T>
struct Sat{
    Sat(vector<T> t):vec(t){};
    int cal(T n){
        return 0;
    }
private:
    vector<T> vec;
    int sum = 0;
};

template<>
int Sat<int>::cal(int n) {
    for (int val:vec){
        if (val==n){
            sum+=1;
        }
    }
    return sum;
}

template<>
int Sat<string>::cal(string n) {
    for (string val:vec){
        if (val==n){
            sum+=1;
        }
    }
    return sum;
}



int main(){
    vector<int> test1 = {1, 2, 1, 2, 3, 1};
    Sat<int> s1(test1);
    cout << s1.cal(1) << endl; // 3

    vector<string> test2 = {"a", "b", "a", "c", "a", "a"};
    Sat<string> s2(test2);
    cout << s2.cal("a") << endl; // 4

    return 0;
}

16.64

#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <iterator>
#include <memory>
#include <fstream>
#include <algorithm>
#include <functional>
#include <map>
#include <set>
#include <sstream>
using namespace std;


template <typename T>
struct Sat{
    Sat(vector<T> t):vec(t){};
    int cal(T n){
        return 0;
    }
private:
    vector<T> vec;
    int sum = 0;
};

template<>
int Sat<int>::cal(int n) {
    for (int val:vec){
        if (val==n){
            sum+=1;
        }
    }
    return sum;
}

template<>
int Sat<string>::cal(string n) {
    for (string val:vec){
        if (val==n){
            sum+=1;
        }
    }
    return sum;
}


template<>
int Sat<const char *>::cal(const char *n) {
    for (const char *val:vec){
        if (strcmp(val, n)==0){
            sum +=1;
        }
    }
    return sum;
}



int main(){
    vector<int> test1 = {1, 2, 1, 2, 3, 1};
    Sat<int> s1(test1);
    cout << s1.cal(1) << endl; // 3

    vector<string> test2 = {"a", "b", "a", "c", "a", "a"};
    Sat<string> s2(test2);
    cout << s2.cal("a") << endl; // 4

    char ch1[] = "hello";
    char *p1 = ch1;
    char ch2[] = "world";
    char *p2 = ch2;

    vector<const char *> test3 = {p1, p2, p1};
    Sat<const char *> s3(test3);
    cout << s3.cal("hello") << endl;


    return 0;
}
HELLOWORLD2424
关注
C++泛型编程
蹦跶跶
06-04 6414
C++泛型编程与STL总结1. 泛型编程1.1 模板1.2 函数模板1.2.1 语法1.2.2 使用函数模板方式1.2.3 普通函数和函数模板的区别1.2.4 普通函数与函数模板的调用规则1.2.5 模板的局限性1.3 类模板2. STL技术 1. 泛型编程 泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。（参考自Bai
C++中的泛型编程
木子皿--啥都不会的菜鸟
02-13 483
文章目录1 C++中的泛型编程1.1 引入1.2 泛型编程 1 C++中的泛型编程 1.1 引入 发散性问题：C++中有几种交换变量的方法？ 交换变量的方法：定义宏代码块和定义函数。 示例代码如下： #include <iostream> #include <string> using namespace std; #define SWAP(t, a, b) \ ...
C++快速理解之泛型编程
挥剑决浮云的博客
08-13 790
在上述示例中，定义了一个函数模板 maximum，它接受两个类型相同的参数，并返回较大的值。它允许定义一个模板，其中的类型参数可以在使用时被实例化为具体的类型，从而创建多个具有相似结构和行为的类。在类模板中，我们使用 T* elements 定义了一个动态数组的指针，并使用 int size 定义了数组的大小。函数模板本身并不是一个具体的函数定义，而是一个通用的模板，用于生成特定类型的函数定义。通过使用泛型，可以编写通用的数据结构和算法，使其适用于不同的数据类型，从而提高代码的复用性和扩展性。
【C++】泛型编程
weixin_45423515的博客
08-31 5614
为了让函数或者类有更好的复用性，C++引入了摸板的技术。让不同的数据类型，能使用到相同的函数或者类中去，这种编程的思想也叫做泛型编程。
C++ Primer 第五版 ——《第十六章 》“ 模板与泛型编程 ” 学习笔记
TAOTAO
03-11 1180
目录 函数模板 模板类型参数 （579P） 非类型模板参数 （580P） 给函数模板 定义 inline 和 constexpr 关键字 （581P） less 关键字 （581P） 模板编译 （582P） 模板的编译错误主要是在实例化过程中报告的 ( 582P) 类模板 （583P） 在类模板作用域内引用其它模板类型 （585P） 对于一个实例化了的类模板,类模板的成员...
C++ Primer学习笔记详解
最新发布
09-14
内容概要：这是关于《C++ Primer学习笔记》的文章，涵盖多种类型转换、异常机制、类静态成员、IO库介绍、顺序容器操作、泛型算法应用、关联容器概念与使用详解、动态内存智能指针管理、构造函数与拷贝构造细节探讨、...
C++ primer plus第6版部分章节学习笔记以及代码记录
10-17
总的来说，这份C++PRIMERplus学习笔记word版本是深入学习C++的好助手，无论你是初学者还是有一定经验的开发者，都能从中受益匪浅。通过系统阅读和实践，你可以逐步掌握C++编程，为今后的软件开发打下坚实基础。
c++ primer笔记
11-19
根据给定的信息，“c++ primer笔记”主要围绕经典著作《C++ Primer》展开，这是一本深受程序员喜爱的书籍，旨在帮助读者系统地学习和掌握C++编程语言的基础及高级特性。下面将从几个关键方面对C++的核心知识点进行...
C/C++学习路线总结与分享
热门推荐
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
C++ 的泛型编程
weixin_62789590的博客
07-15 744
这个思想其实有两个层面，1、编写与数据类型无关的代码；2、使用模版元；
C++--泛型编程
diyxuan的博客
07-08 1143
泛型编程的使用方法以及应用实例
C++之泛型编程
m0_60027772的博客
12-24 1931
建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型函数声明或函数定义解释：声明创建模板表明其后面的符号为一种数据类型（该关键字也可以用class代替）通用的数据类型；名称可以替换，通常为大写字母。建立一个通用的类，类中的成员，数据类型可以不具体指定，用一个虚拟的类型来代表类解释：声明创建模板表明其后面带符号的是一种数据类型（也可以用class替换）
C++的泛型编程
Albert_weiku的博客
06-23 939
屏蔽掉数据和操作数据的细节，让算法更为同意通用，让编程者更多地关注算法的结构，而不是在算法中处理不同的数据类型
C++ 泛型编程
zy1872071381的博客
08-26 707
C++泛型编程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值