6.4-数据结构&算法-模板/函数模板/类模板/特化

最新推荐文章于 2024-04-26 20:40:23 发布
最新推荐文章于 2024-04-26 20:40:23 发布
阅读量97 收藏
点赞数
文章标签： 数据结构与算法 测试
原文链接：http://www.cnblogs.com/xuxaut-558/p/10028385.html
版权
一、为什么要有模板？
将类型参数化，可以实现算法与类型的分离，编写针对类型更加抽象的函数或者类。
 
二、函数模板
通用定义：
template<typename 类型形参1, ...>
返回类型 函数模板名 (形参表) { ... }
特化定义：
template<>
返回类型 函数模板名<类型实参1, ...> (形参表) { ... }
 
三、类模板
通用定义：
template<typename 类型形参1, ...>
class 类模板名 { ... };
全类特化：
template<>
class 类模板名<类型实参1, ...> { ... };
成员特化：
template<>
返回类型 类模板名<类型实参1, ...> ::成员函数名 (形参表) { ... }
 
四、局部特化
 
五、非类型参数和缺省参数
1.非类型参数的实参仅限于常量或者常量表达式。
2.无论类型参数还是非类型参数都可以带有缺省值，而且和函数的缺省参数一样，模板的缺省参数也必须靠右。
 
六、有关模板的其它问题
1.从模板继承
2.向模板派生
3.模板中模板成员
1)模板型成员变量
2)模板型成员函数
3)模板型成员类型
4.模板型模板实参
 
七、容器和迭代器
arg.cpp 
#include <iostream>
using namespace std;
template<typename T>
class A {
public:
    A (const T& t) : m_t (t) {}
    T m_t;
};
template<typename X, typename Z,
    template<typename T> class Y>
class B {
public:
    B (const X& i, const Z& s) :
        m_i (i), m_s (s) {}
    Y<X> m_i;
    Y<Z> m_s;
};
int main (void) {
    B<int, string, A> b (100, "hello");
    cout << b.m_i.m_t << ' ' << b.m_s.m_t << endl;
    return 0;
}

 

array.cpp

#include <iostream>
using namespace std;
template<typename T = int, size_t S = 5>
class Array {
public:
    T& operator[] (size_t i) {
        return m_array[i];
    }
    const T& operator[] (size_t i) const {
        return const_cast<Array&> (*this) [i];
    }
    size_t size (void) const {
        return S;
    }
    friend ostream& operator<< (ostream& os,
        const Array& arr) {
        for (size_t i = 0; i < arr.size (); ++i)
            os << '(' << arr.m_array[i] << ')';
        return os;
    }
private:
    T m_array[S];
};
int main (void) {
    const /*volatile*/ int x = 3, y = 7;
    Array<int, x+y> arr;
    for (size_t i = 0; i < arr.size (); ++i)
        arr[i] = i;
    cout << arr << endl;
    Array<Array<int, 4>, 3> m;
    for (size_t i = 0; i < m.size (); ++i)
        for (size_t j = 0; j < m[i].size (); ++j)
            m[i][j] = i * m[i].size () + j;
    cout << m << endl;
    Array<double> a2;
    Array<> a3;
    return 0;
}

 

cmp.cpp

#include <iostream>
#include <cstring>
using namespace std;
// 通用模板
template<typename T>
class Comparator {
public:
    Comparator (T x, T y) : m_x (x), m_y (y) {}
    T min (void) const {
        return m_x < m_y ? m_x : m_y;
    }
    T max (void) const {
        return m_x > m_y ? m_x : m_y;
    }
private:
    T m_x;
    T m_y;
};
/*
// 针对char*的全模板特化
template<>
class Comparator<char*> {
public:
    Comparator (char* x, char* y) :
        m_x (x), m_y (y) {}
    char* min (void) const {
        return strcmp (m_x, m_y) < 0 ? m_x : m_y;
    }
    char* max (void) const {
        return strcmp (m_x, m_y) > 0 ? m_x : m_y;
    }
private:
    char* m_x;
    char* m_y;
};
*/
// 针对char*的成员函数特化
template<>
char* Comparator<char*>::min (void) const {
    return strcmp (m_x, m_y) < 0 ? m_x : m_y;
}
template<>
char* Comparator<char*>::max (void) const {
    return strcmp (m_x, m_y) > 0 ? m_x : m_y;
}
int main (void) {
    cout << "输入两个整数：" << flush;
    int nx, ny;
    cin >> nx >> ny;
    Comparator<int> cn (nx, ny);
    cout << "最小值：" << cn.min () << endl;
    cout << "最大值：" << cn.max () << endl;
    cout << "输入两个字符串：" << flush;
    string sx, sy;
    cin >> sx >> sy;
    Comparator<string> cs (sx, sy);
    cout << "最小值：" << cs.min () << endl;
    cout << "最大值：" << cs.max () << endl;
    cout << "输入两个字符串：" << flush;
    char cx[256], cy[256];
    cin >> cx >> cy;
    Comparator<char*> cc (cx, cy);
    cout << "最小值：" << cc.min () << endl;
    cout << "最大值：" << cc.max () << endl;
    return 0;
}

 

inher.cpp

#include <iostream>
using namespace std;
template<typename T>
class A {
public:
    A (const T& t) : m_t (t) {}
    T m_t;
};
template<typename T, typename Y>
class B : public A<T> {
public:
    B (const T& t, const Y& y) :
        A<T> (t), m_y (y) {}
    Y m_y;
};
int main (void) {
    B<int, string> b (100, "hello");
    cout << b.m_t << ' ' << b.m_y << endl;
    return 0;
}

 

inter.cpp

#include <iostream>
using namespace std;
template<typename T>
class A {
public:
    class B {};
};
template<typename T>
void foo (void) {
    typename A<T>::B b;
}
int main (void) {
    foo<int> ();
    return 0;
}

 

list.cpp

#include <iostream>
#include <stdexcept>
#include <cstring>
using namespace std;
// 双向线性链表容器模板
template<typename T>
class List {
public:
    // 构造、析构、拷贝构造、拷贝赋值
    List (void) : m_head (NULL), m_tail (NULL) {}
    ~List (void) {
        clear ();
    }
    List (const List& that) : m_head (NULL),
        m_tail (NULL) {
        for (Node* node = that.m_head; node;
            node = node->m_next)
            push_back (node->m_data);
    }
    List& operator= (const List& that) {
        if (&that != this) {
            List list (that);
            swap (m_head, list.m_head);
            swap (m_tail, list.m_tail);
        }
        return *this;
    }
    // 获取首元素
    T& front (void) {
        if (empty ())
            throw underflow_error ("链表下溢！");
        return m_head->m_data;
    }
    const T& front (void) const {
        return const_cast<List*> (this)->front ();
    }
    // 向首部压入
    void push_front (const T& data) {
        m_head = new Node (data, NULL, m_head);
        if (m_head->m_next)
            m_head->m_next->m_prev = m_head;
        else
            m_tail = m_head;
    }
    // 从首部弹出
    void pop_front (void) {
        if (empty ())
            throw underflow_error ("链表下溢！");
        Node* next = m_head->m_next;
        delete m_head;
        m_head = next;
        if (m_head)
            m_head->m_prev = NULL;
        else
            m_tail = NULL;
    }
    // 获取尾元素
    T& back (void) {
        if (empty ())
            throw underflow_error ("链表下溢！");
        return m_tail->m_data;
    }
    const T& back (void) const {
        return const_cast<List*> (this)->back ();
    }
    // 向尾部压入
    void push_back (const T& data) {
        m_tail = new Node (data, m_tail);
        if (m_tail->m_prev)
            m_tail->m_prev->m_next = m_tail;
        else
            m_head = m_tail;
    }
    // 从尾部弹出
    void pop_back (void) {
        if (empty ())
            throw underflow_error ("链表下溢！");
        Node* prev = m_tail->m_prev;
        delete m_tail;
        m_tail = prev;
        if (m_tail)
            m_tail->m_next = NULL;
        else
            m_head = NULL;
    }
    // 删除所有匹配元素
    void remove (const T& data) {
        for (Node* node = m_head, *next; node;
            node = next) {
            next = node->m_next;
            if (equal (node->m_data, data)) {
                if (node->m_prev)
                    node->m_prev->m_next =
                        node->m_next;
                else
                    m_head = node->m_next;
                if (node->m_next)
                    node->m_next->m_prev =
                        node->m_prev;
                else
                    m_tail = node->m_prev;
                delete node;
            }
        }
    }
    // 清空
    void clear (void) {
        for (Node* next; m_head; m_head = next) {
            next = m_head->m_next;
            delete m_head;
        }
        m_tail = NULL;
    }
    // 判空
    bool empty (void) const {
        return ! m_head && ! m_tail;
    }
    // 获取大小
    size_t size (void) const {
        size_t count = 0;
        for (Node* node = m_head; node;
            node = node->m_next)
            ++count;
        return count;
    }
    // 插入输出流
    friend ostream& operator<< (ostream& os,
        const List& list) {
        for (Node* node = list.m_head; node;
            node = node->m_next)
            os << *node;
        return os;
    }
private:
    // 节点
    class Node {
    public:
        Node (const T& data = 0, Node* prev = NULL,
            Node* next = NULL) : m_data (data),
            m_prev (prev), m_next (next) {}
        friend ostream& operator<< (ostream& os,
            const Node& node) {
            return os << '(' << node.m_data << ')';
        }
        T m_data; // 数据
        Node* m_prev; // 前指针
        Node* m_next; // 后指针
    };
    bool equal (const T& a, const T& b) const {
        return a == b;
    }
    Node* m_head; // 头指针
    Node* m_tail; // 尾指针
public:
    // 正向迭代器
    class Iterator {
    public:
        Iterator (Node* head = NULL,
            Node* tail = NULL, Node* node = NULL) :
            m_head (head), m_tail (tail),
            m_node (node) {}
        bool operator== (const Iterator& it) const {
            return m_node == it.m_node;
        }
        bool operator!= (const Iterator& it) const {
            return ! (*this == it);
        }
        Iterator& operator++ (void) {
            if (m_node)
                m_node = m_node->m_next;
            else
                m_node = m_head;
            return *this;
        }
        const Iterator operator++ (int) {
            Iterator old = *this;
            ++*this;
            return old;
        }
        Iterator& operator-- (void) {
            if (m_node)
                m_node = m_node->m_prev;
            else
                m_node = m_tail;
            return *this;
        }
        const Iterator operator-- (int) {
            Iterator old = *this;
            --*this;
            return old;
        }
        T& operator* (void) const {
            return m_node->m_data;
        }
        T* operator-> (void) const {
            return &**this;
        }
    private:
        Node* m_head;
        Node* m_tail;
        Node* m_node;
        friend class List;
    };
    Iterator begin (void) {
        return Iterator (m_head, m_tail, m_head);
    }
    Iterator end (void) {
        return Iterator (m_head, m_tail);
    }
    Iterator insert (Iterator loc, const T& data) {
        if (loc == end ()) {
            push_back (data);
               return Iterator (m_head, m_tail,m_tail);
        }
        else {
            Node* node = new Node (data,
                loc.m_node->m_prev, loc.m_node);
            if (node->m_prev)
                node->m_prev->m_next = node;
            else
                m_head = node;
            node->m_next->m_prev = node;
            return Iterator (m_head, m_tail, node);
        }
    }
    Iterator erase (Iterator loc) {
        if (loc == end ())
            throw invalid_argument ("无效迭代器！");
        if (loc.m_node->m_prev)
            loc.m_node->m_prev->m_next =
                loc.m_node->m_next;
        else
            m_head = loc.m_node->m_next;
        if (loc.m_node->m_next)
            loc.m_node->m_next->m_prev =
                loc.m_node->m_prev;
        else
            m_tail = loc.m_node->m_prev;
        Node* next = loc.m_node->m_next;
        delete loc.m_node;
        return Iterator (m_head, m_tail, next);
    }
};
// 针对const char*的特化
template<>
bool List<const char*>::equal (const char* const& a,
    const char* const& b) const {
    return strcmp (a, b) == 0;
}
// 测试用例
int main (void) {
    try {
        List<int> list1;
        list1.push_front (20);
        list1.push_front (10);
        list1.push_back (30);
        list1.push_back (40);
        cout << list1 << endl;
        cout << list1.front () << ' ' <<
            list1.back () << endl;
        list1.pop_front ();
        list1.pop_back ();
        cout << list1 << endl;
        ++list1.front ();
        --list1.back ();
        cout << list1 << endl;
        list1.push_back (21);
        list1.push_back (25);
        list1.push_back (21);
        list1.push_back (21);
        cout << list1 << endl;
        list1.remove (21);
        cout << list1 << endl;
        List<int> list2 = list1;
        cout << list2 << endl;
        list2.back () = 100;
        cout << list2 << endl;
        cout << list1 << endl;
        list2 = list1;
        cout << list2 << endl;
        list2.front () = 100;
        cout << list2 << endl;
        cout << list1 << endl;
        cout << list1.size () << endl;
        list1.clear ();
        cout << list1 << endl;
        cout << boolalpha << list1.empty () << endl;
//        List<string> list3;
        List<const char*> list3;
        list3.push_back ("beijing");
        list3.push_back ("tianjin");
        list3.push_front ("tianjin");
        list3.push_back ("shanghai");
        list3.push_back ("beijing");
        cout << list3 << endl;
        list3.remove (string ("beijing").c_str ());
        cout << list3 << endl;
        for (List<const char*>::Iterator it =
            list3.begin (); it != list3.end ();
            ++it)
            cout << *it << ' ';
        cout << endl;
        List<const char*>::Iterator it =
            list3.begin ();
        it++;
        it = list3.insert (it, "chongqing");
        cout << list3 << endl;
        list3.erase (it);
        cout << list3 << endl;
    }
    catch (exception& ex) {
        cout << ex.what () << endl;
        return -1;
    }
    return 0;
}

 

max.cpp

#include <iostream>
using namespace std;
int max_int (int x, int y) {
    return x > y ? x : y;
}
string max_str (string x, string y) {
    return x > y ? x : y;
}
int main (void) {
    cout << "输入两个整数：" << flush;
    int nx, ny;
    cin >> nx >> ny;
    cout << "最大值：" << max_int (nx, ny) << endl;
    cout << "输入两个字符串：" << flush;
    string sx, sy;
    cin >> sx >> sy;
    cout << "最大值：" << max_str (sx, sy) << endl;
    return 0;
}

 

max2.cpp

#include <iostream>
#include <typeinfo>
#include <cstring>
using namespace std;
// 函数模板/模板函数
template<typename T>
T Max (T x, T y) {
    cout << typeid (T).name () << endl;
    return x > y ? x : y;
}
// 模板特化
template<>
char* Max<char*> (char* x, char* y) {
    return strcmp (x, y) > 0 ? x : y;
}
template<typename T>
void foo (void) {
    T t;
    cout << typeid (t).name () << endl;
}
int main (void) {
    cout << "输入两个整数：" << flush;
    int nx, ny;
    cin >> nx >> ny;
    cout << "最大值：" << Max (nx, ny) << endl;
    cout << "输入两个字符串：" << flush;
    string sx, sy;
    cin >> sx >> sy;
    cout << "最大值：" << Max (sx, sy) << endl;
    cout << "输入两个字符串：" << flush;
    char cx[256], cy[256];
    cin >> cx >> cy;
    cout << "最大值：" << Max (cx, cy) << endl;
    /*
    foo<int> ();
    foo<double> ();
    foo<string> ();
    */
    return 0;
}

 

memb1.cpp

#include <iostream>
using namespace std;
template<typename T>
class A {
public:
    A (const T& t) : m_t (t) {}
    T m_t;
};
template<typename T, typename Y>
class B {
public:
    B (const T& t, const Y& y) :
        m_a (t), m_y (y) {}
    A<T> m_a;
    Y m_y;
};
int main (void) {
    B<int, string> b (100, "hello");
    cout << b.m_a.m_t << ' ' << b.m_y << endl;
    return 0;
}

 

memb2.cpp

#include <iostream>
using namespace std;
template<typename T>
class A {
public:
    A (const T& t) : m_t (t) {}
    /*
    template<typename Y>
    void print (const Y& y) {
        cout << m_t << ' ' << y << endl;
    }
    */
    template<typename Y>
    void print (const Y& y);
    T m_t;
};
template<typename T>
    template<typename Y>
void A<T>::print (const Y& y) {
    cout << m_t << ' ' << y << endl;
}
int main (void) {
    A<int> a (100);
    a.print<string> ("hello");
    return 0;
}

 

memb3.cpp

#include <iostream>
using namespace std;
template<typename T, typename Y>
class A {
public:
    A (const T& t, const Y& y) :
        m_t (t), m_b (y) {}
    /*
    template<typename X>
    class B {
    public:
        B (const X& x) : m_x (x) {}
        X m_x;
    };
    */
    template<typename X> class B;
    T m_t;
    B<Y> m_b;
};
template<typename T, typename Y>
    template<typename X>
class A<T, Y>::B {
public:
    B (const X& x) : m_x (x) {}
    X m_x;
};
int main (void) {
    A<int, string> a (100, "hello");
    cout << a.m_t << ' ' << a.m_b.m_x << endl;
    return 0;
}

 

part.cpp

#include <iostream>
using namespace std;
template<typename T1, typename T2>
class A {
public:
    A (void) {
        cout << "A<T1,T2>" << endl;
    }
};
template<typename T1>
class A<T1, int> {
public:
    A (void) {
        cout << "A<T1,int>" << endl;
    }
};
template<>
class A<int, int> {
public:
    A (void) {
        cout << "A<int,int>" << endl;
    }
};
template<typename T>
class B {
public:
    B (void) {
        cout << "B<T>" << endl;
    }
};
template<typename T>
class B<T*> {
public:
    B (void) {
        cout << "B<T*>" << endl;
    }
};
template<typename T>
class B<T[]> {
public:
    B (void) {
        cout << "B<T[]>" << endl;
    }
};
template<typename T1, typename T2, typename T3>
class C {
public:
    C (void) {
        cout << "C<T1,T2,T3>" << endl;
    }
};
template<typename T1, typename T2>
class C<T1, T2, T2> {
public:
    C (void) {
        cout << "C<T1,T2,T2>" << endl;
    }
};
template<typename T1>
class C<T1, T1*, T1*> {
public:
    C (void) {
        cout << "C<T1,T1*,T1*>" << endl;
    }
};
int main (void) {
    // 特化程度高的优先
    A<double, double> a1;
    A<double, int> a2;
    A<int, int> a3;
    // 针对指针和数组的特化优先
    B<char> b1;
    B<char*> b2;
    B<char[]> b3;
    // 匹配度高的特化优先
    C<char, short, long> c1;
    C<char, short, short> c2;
    C<char, char*, char*> c3;
    return 0;
}

 

shape.cpp

#include <iostream>
using namespace std;
template<typename BASE>
class Shape : public BASE {
public:
    void draw (void) const {
        BASE::draw ();
    }
};
class Rect {
public:
    void draw (void) const {
        cout << "绘制矩形..." << endl;
    }
};
class Circle {
public:
    void draw (void) const {
        cout << "绘制圆形..." << endl;
    }
};
int main (void) {
    Shape<Rect> shape1;
    shape1.draw ();
    Shape<Circle> shape2;
    shape2.draw ();
    return 0;
}

 

 
 
 
 
 
 
 
 
 

转载于:https://www.cnblogs.com/xuxaut-558/p/10028385.html

weixin_34072458
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构6.4文件
李洲谊
01-19 1340
文件的基本概念 定义 文件（file）是由大量性质相同的记录组成的集合。文件的数据量通常很大，被放置在外存储器上。 分类 一：按其记录类型的不同分为如下两类： 1.操作系统的文件：是一维的无结构、无结束的连续字符序列 2.数据库文件：是带有结构的记录的集合，每条记录由一个或多个数据项组成。记录是文件中存取的基本单位，数据项是文件中可使用的数据的最小单位。 二：按记录长度是否相同分为如下两类： 1....
C++模板编程中只特化模板类的一个成员函数
01-20
模板编程中如果要特化或偏特化(局部特化)一个类模板，需要特化该类模板的所有成员函数。类模板中大多数成员函数的功能可能是一模一样的，特化时我们可能只需要重新实现1、2个成员函数即可。在这种情况下，如果全部...
【数据结构】c++之函数模板
一拳Marx
01-30 90
【数据结构】c++之函数模板出现原因：此时用一个模板函数代替类的声明即可然后调用主函数 出现原因： 函数重载构成中有大量重复字段，这个时候需引入模板 #include<iostream> //int类型数据交换 void Myswap(int &a,int &b){ int temp=a; a=b; b=temp; } //double类型数据交换 void Myswap(double& a,double& b){ double temp=a; a=b;
数据结构_模板（template）
AMWICD的博客
09-17 989
1.模板是对具有相同特性的函数或类的再抽象，模板是一种参数化的多态性工具。所谓参数化多态性，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理多种不同类型的对象。 2.模板分为：函数模板、类模板。模板通过参数实例化可以构建具体的函数或类，称为模板函数和模板类。而模板类参数实例化可以构建对象。 3.如果要对一个数求绝对值，当变量类型分别为int和double时，所写代码十分相似，只略微有...
C语言基础：求结构体数组中的最大值并按序输出
文优
01-13 4206
C语言基础：求结构体数组成员列表中的成绩最大值并按序输出 1. 用结构体数组进行传参 例1： #include "stdafx.h" #include <stdio.h> #define member 5//成员数 #define NAME_LEN 20//姓名最大长度 struct st { int id; char name[NAME_LEN]; double score; }; int max_score_id(struct st st[], int size)//结构体数组
数据结构与算法模板
darknight
09-15 1316
经常打codeforce，比赛，给学生讲算法那的啥啊的都需要模板 那么也把我整理的这些基础数据结构与算法的模板分享给大家 可能有一点点小错误，可以在评论区留言哈~ namespace I_love_xinxin{ /* 名称定义： n: 数据规模 m: 表示边数等数据规模 v: vertex 图中的顶点 fa: father 一般用来指代父亲 r......
C++ 类模板、函数模板全特化、偏特化的使用
12-20
一、类模板全特化、偏特化 #pragma once #include #include template class TC { public: TC() { std::cout << "泛化版本构造函数" < class TC { public: TC() { std::cout << "全特化版本...
C++第59课–类模板深度剖，类模板的特化，函数模板的特化
01-06
实验2：特化的深入理解：函数模板的完全特化 实验1：类模板的特化 #include #include using namespace std; template class Test { public: void add(T1 a, T2 b) { cout << void add(T1 a, T2 b) &lt...
解读C++编程中类模板的三种特化
12-26
1.类模板显式特化 为了进行特化,首先需要一个通用的版本,称主模板.主模板使用了标准库堆算法. 堆 是一种线性化的树形结构,将一个值压入一个堆中, 实际上等于将该值插入到一个树形结构中;将一个值从堆中取出就等于...
网络编程-数据结构与函数详解
chen1415886044的博客
02-25 841
在网络编程-一个简单的客户端与服务器程序(0)，（看这篇就够了）中已经对程序整体有了宏观的认识。这篇主要对数据结构与函数详解。 数据结构与函数详解 IPv4相关结构： struct in_addr { in_addr_t s_addr; //表示32位的IP地址，32位无符号整型 } struct sockaddr_in { uint8_t ...
数据结构：模板
weixin_43460331的博客
09-21 318
数据结构：模板 模板概述： (1)模板是对具有相同特性的函数或类的再抽象，模板是一种参数化的多态性工具。 (2)所谓参数化多态性，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理多种不同类型的对象。 (3)采用模板编程，可以为各种逻辑功能相同而数据类型不同的程序提供一种代码共享的机制。 模板分类： 函数模板、类模板 模板的实例化： 模板通过参数实例化可以构...
【C++】深入理解模板
Making Life Better. Making Others Better.
12-12 1254
1、简介模板是一种代码复用方式，其它的代码复用方式还包括继承和组合。当我们使用模板时，参数由编译器来替换，这非常像原来的宏方法，但却更清晰、更容易使用。在C++中，模板实现了参数化类型的概念，放在一对尖括号中，通过template这个关键字，告诉编译器随后的定义将操作一个或更多未指明的类型，当由这个模板产生实际代码时，必须指定这些类型以使编译器能够替换它们。下面是一个简单的模板类。template
数据结构与算法——插入排序——使用C++实现函数模板
jay_zzs的博客
07-31 929
1. 插入排序原理 插入排序是最基本的排序算法，之前写过一篇文章实现插入排序，不过是用的C语言+函数指针，使得用户可以自定义升序排序还是降序排序。 现在考虑使用C++，将该算法做成一个函数模板。 2. 将排序算法做成函数模板 几个关键字：【函数模板】，【函数对象】，【匿名函数】，【友元函数】。 对于基本数据类型，构建函数模板比较简单，排序的比较也可以直接用STL里面的less和great函数对象。对于自定义类型的数据，需要实现自定义类型对象的比较，可以1）重载比较运算符，less重载"<"运
数据结构与算法——常见排序算法写成模板，新建命名空间打包带走
jay_zzs的博客
09-03 222
1. 前文汇总 前面陆陆续续总结过常用排序算法，如下： 数据结构与算法——快排序 数据结构与算法——插入排序 C++——归并排序，从固定数据类型到函数模板以及使用函数对象自定义递增/递减 数据结构与算法——插入排序——使用C++实现函数模板、 数据结构与算法——希尔排序 数据结构与算法——选择排序 2. 常用排序算法整理 将常用的排序算法进行了实现，写成了模板，并放在了一个命名空间下面。包括插入排序，选择排序，希尔排序，快排序，堆排序和归并排序。 需要注意的就是模板的特化，不能将模板函数
力扣---从中序与后序遍历序列构造二叉树
m0_71536793的博客
04-20 445
力扣 中序遍历 后序遍历 建树
vue 实现级联选择器功能
清音的博客
04-22 509
数组包含了级联选择器的数据源，其中每个对象表示一个选项，包括。组件来实现级联选择器功能,下面是一个示例代码，演示如何使用。组件初始化级联选择器，并设置默认值为单位。对象用于指定数据结构中的属性名，以便。上，可以在初始化时选中指定的值。使用 Element UI 的。中设置初始选中值为单位。组件正确地解析数据。
泛型编程介绍
最新发布
热土程序园：分享技术，利他愉己~
04-26 621
泛型编程（Generic Programming） 在计算机科学中，是一种允许一个值取不同数据类型（所谓多态）的技术。这种编程风格强调使用泛型技术，旨在推出一种针对算法、数据结构和内存分配机制的分类方法，以及其他能够带来高度可重用性、模块化和可用性的软件工具。 泛型这个词并不是通用的，在不同的语言实现中，具有不同的命名。在Java/Kotlin/C#中称为泛型（Generics），在ML/Scala/Haskell中称为Parametric Polymorphism，而在C++中被叫做模板.
DFS和回溯专题：子集
孤舟一叶～的博客
04-23 248
因为题目要求的是数组所有可能的子集，所以通过回溯遍历出来的所有结果都可以添加到结果列表中，代码直接套用回溯模版即可。
栈的基本操作（c语言实现）
2301_80224556的博客
04-25 604
/栈中存储的元素类型（这里用整型举例）//栈int top;//栈顶//容量，方便增容}Stack;这里定义了一个结构体，并给它起了一个别名Stack。a：这是一个指向STDataType类型的指针，用于存储栈中的元素。它实际上是一个数组，用来存放栈中的各个元素。top：这是一个整数，表示栈顶的位置。在栈中，通常使用top来追踪栈顶元素的位置。当栈为空时，top的值可能是-1或其他表示空栈的值；当栈不为空时，top的值是栈顶元素的索引。capacity：这也是一个整数，表示栈的容量。
c++ 函数模板特化
08-19
C++ 函数模板特化是指为特定的数据类型或者特定的函数参数提供特殊的实现。这样可以在处理某些特殊情况时，使用不同的实现逻辑，以满足特定的需求。 函数模板特化的语法如下： ```cpp template return_type ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值