精华内容
下载资源
问答
  • C++类模板继承 类模板继承 类模板 继承类模板碰到继承时,需要注意以下几点: 当子类继承的父类是一个类模板时,子类在声明的时候,要指定出父类的类型T 如果不指定,编译器无法给子类分配内存 如果想灵活...

    C++类模板与继承 类模板与继承 类模板 继承
    当类模板碰到继承时,需要注意以下几点:

    • 当子类继承的父类是一个类模板时,子类在声明的时候,要指定出父类的类型T
    • 如果不指定,编译器无法给子类分配内存
    • 如果想灵活指定出父类中的T的类型,子类也需变为类模板
    #include <iostream>
    using namespace std;
    //类模板与继承
    //当子类继承的父类是一个类模板时,子类在声明的时候,要指定出父类中T的类型
    //如果不指定,编译器无法给子类分配内存
    //如果想灵活指定出父类中T的类型,子类也需要变为类模板
    template<class T>
    class Base
    {
    	T m;
    };
    //class Son : public Base		//错误, C++编译需给子类分配内存,必须知道父类中T的类型才可以向下继承
    class Son : public Base<int>	//必须指定一个类型
    {
    
    };
    void test01()
    {
    	Son c;
    }
    //类模板继承类模板,可以用T2指定父类中的T类型
    template<class T1, class T2>
    class Son2 : public Base<T2>
    {
    public:
    	Son2()
    	{
    		cout << typeid(T1).name() << endl;
    		cout << typeid(T2).name() << endl;
    	}
    };
    void test02()
    {
    	Son2<int, char>child;
    }
    int main()
    {
    	test01();
    	test02();
    	return 0;
    }
    

    总结:如果父类是类模板, 子类需要指定出父类中T的数据类型
    C++类模板与继承 类模板与继承 类模板 继承

    展开全文
  •  模板类继承是C++中较为高级的一种用法,其语法与普通C++类的继承略有差别。本文实例演示了一个通过C++模板类继承实现排序算法的案例。代码如下: 1. 实现List基类 #ifndef LIST_H #define LIST_H #include ...

           大学时代旧作。

          模板类的继承是C++中较为高级的一种用法,其语法与普通C++类的继承略有差别。本文实例演示了一个通过C++模板类继承实现排序算法的案例。代码如下:

    1.   实现List基类

    #ifndef LIST_H
    
    #define LIST_H
    
    #include <iostream>
    
    using std::cout;
    
    using std::endl;
    
     
    
    enum Error_code { underflow, overflow, range_error, success, not_present,fail};
    
    const int max_list = 100;
    
     
    
    template <class List_entry>
    
    class List
    
    {
    
           // methods of List ADT
    
    public:
    
     
    
           List();
    
           int size() const;
    
           bool full() const;
    
           bool empty() const;
    
           void clear();
    
           void traverse(void(*vist)(List_entry&));  // Traverse every elements in the List
    
           Error_code retrieve(int position, List_entry &x) const;
    
           Error_code replace(int position, const List_entry& x);
    
           Error_code  remove(int position, List_entry& x);
    
           Error_code  insert(int position, const List_entry &x);
    
     
    
    protected:
    
     
    
           // The contiguous implementation is based on the array
    
           int count;
    
           List_entry entry[max_list];
    
    };
    
    // constructor
    
    template<class List_entry>
    
    List<List_entry>:: List()
    
    {
    
           count = 0;
    
    }
    
    /***** 其余代码略***********/
    
    #endif
    


    2. 从模板类中派生一个模板子类

    #ifndef SORTABLE_LIST
    
    #define SORTABLE_LIST
    
     
    #include "list.h"
    
     
    
    template<class Record>
    
    class Sortable_list : public List<Record>
    
    {
    
       public:
    
              Sortable_list();
    
     
    
              // Insertion sorting
    
              void insertion_sort();
    
     
    
              // Selection sorting
    
              void selection_sort();
    
              int max_key(int low, int high);
    
              void swap(int low, int high);
    
     
    
              // Shell sorting
    
              void shell_sort();
    
              void sort_interval(int low, int increment);
    
     
    
           // Quick sorting
    
              void quick_sort();
    
              void recursive_quick_sort(int low, int high);
    
              int partition(int low, int high);
    
     
    
              // Heap sorting
    
              void heap_sort();
    
              void insert_heap(const Record& current, int low, int high);
    
              void build_heap();
    
     
    
    };
    
    // 派生类的构造函数,注意其语法差别
    
    template<class Record>
    
    Sortable_list<Record>::Sortable_list():List<Record>(){}
    
    /********************其余代码略**************************************/
    
    #endif
    
    

    3. 测试代码


    
    #include <iostream>
    
    using std::cout;
    
    using std::endl;
    
     
    
    #include "list.h"
    
    #include "Sortable_list.h"
    
     
    
    void print(int &a)
    
    {
    
           cout<<a<<" ";
    
    }
    
    int main()
    
    {
    
        Sortable_list<int> myList;
    
           myList.insert(0,6);
    
           myList.insert(0,56);
    
           myList.insert(0,7);
    
           myList.insert(2,57);
    
           myList.insert(1,4);
    
           myList.insert(3,23);
    
           myList.insert(0,9);
    
           myList.insert(5,45);
    
           myList.insert(4,17);
    
           myList.insert(0,7);
    
           myList.insert(6,89);
    
           myList.insert(6,34);
    
           myList.insert(2,35);
    
      
    
           // Sortable list to test different soring methods
    
        Sortable_list<int> myList2 = myList;
    
           Sortable_list<int> myList3 = myList;
    
           Sortable_list<int> myList4 = myList;
    
           Sortable_list<int> myList5 = myList;
    
     
    
           // Print out the original list
    
           cout<<"All the entries in the original list: "<<endl;
    
           myList.traverse(print);
    
           cout<<endl;
    
     
    
        
    
        // Test the insert sorting
    
           cout<<"After the insert soring, we get:"<<endl;
    
           myList.insertion_sort();
    
           myList.traverse(print);
    
        cout<<endl;
    
     
    
        // Test the selection sorting
    
           cout<<"After the insert soring, we get:"<<endl;
    
           myList2.selection_sort();
    
           myList2.traverse(print);
    
        cout<<endl;
    
     
    
        // Test the shell sorting
    
        cout<<"After the  shell sort,we get :"<<endl;
    
        myList3.shell_sort();
    
         myList3.traverse(print);
    
           cout<<endl;
    
        
    
           // Test the quick sorting
    
        cout<<"After the  quick sort,we get :"<<endl;
    
        myList4.quick_sort();
    
         myList4.traverse(print);
    
           cout<<endl;
    
     
    
        
    
           // Test the heap sorting
    
        cout<<"After the  quick sort,we get :"<<endl;
    
        myList5.heap_sort();
    
         myList5.traverse(print);
    
           cout<<endl;
    
        return 0;
    
     
    
    }
    


    展开全文
  • C++类模板与函数模板 & 类模板继承

    千次阅读 2017-04-13 11:39:22
    函数模板类模板其实就是Java里面的泛型编程,只作为抽象的模板,使用时需要指定具体的类型才能实例 下面就看类模板最典型的案列就能明白了: #include #include #include using namespace std; //类模板 ...

    函数模板与类模板其实就是Java里面的泛型编程,只作为抽象的模板,使用时需要指定具体的类型才能实例

    下面就看类模板最典型的案列就能明白了:

    #include <iostream>
    #include <initializer_list>
    #include <string.h>
    
    using namespace std;
    
    //类模板
    template<class T,int n>
    class Myarray{
    
    public:
    	T* p;
    
    	Myarray(const initializer_list<T>& list){
    		cout << "cons two" << endl;
    		p = new T[n];
    		memset(p, 0, sizeof(T)* n);
    		int length = list.size();
    		if (length > n){
    			abort();
    		}
    		else{
    			int i = 0;
    			for (auto j : list){
    				p[i] = j;
    				i++;
    			}
    		}
    
    	}
    
    
    	void show(){
    		for (int i = 0; i < n; i++){
    			cout << p[i] << endl;
    		}
    	}
    	
    	~Myarray(){
    		
    	}
    
    };
    
    
    void main(){
    
    	Myarray<int, 5> myarray{1,2,3,4,5};
    	myarray.show();
    
    	Myarray<double, 3> mystring{1.2,2.3,4.4};
    	mystring.show();
    
    	cout << typeid(Myarray<string, 12>).name() << endl;
    
    	cin.get();
    }



    二:类模板与类模板的继承必须保持类型一致,类模板与普通类的继承需要指定明确的类型

    先看代码才能了解到底是怎么一回事,模板编程只能自己去理解。

    #include <iostream>
    
    using namespace std;
    
    
    // T 与 T  支持继承  多台
    // T 与 P 之间
    
    
    template<class T>
    class Father{
    
    public:
    	T data;
    
    	void show(){
    		cout << data << endl;
    	}
    
    	virtual void go(){
    		cout << "father go" << endl;
    	}
    
    };
    
    
    
    template<class T>
    class Son : public Father<T>{
    
    public:
    
    	void go(){
    		cout << "son go" << endl;
    	}
    
    };
    
    
    
    void main(){
    
    	//Son<int> myson;
    	//myson.data = 100;
    
    	//myson.Father::show();
    
    	//模板类的集成 也能实现多态
    	Father<int> * father = new Son<int>;
    	father->go();
    
    
    	cin.get();
    }

    模板与普通类之间的继承:

    #include <iostream>
    using namespace std;
    
    template<class T>
    class Teacher{
    
    public:
    	T data;
    
    	void show(){
    		cout << data << endl;
    	}
    
    	virtual void go(){
    		cout << "teacher go" << endl;
    	}
    };
    
    class Son : public Teacher<int>{
    
    };
    



    到这边就应该能看懂类模板了,现在将以下函数模板里的一个知识点就是类包装器,本质就是伪函数如何在函数模板中使用

    很容易联想到函数包装器的使用,可以参考我之前写的博客http://blog.csdn.net/szqsdq/article/details/62423313

    #include <iostream>
    #include <list>
    
    using namespace std;
    
    
    //函数模板
    template<class T,class F>
    T testFunc(T t,F func){
    	return func(t);
    }
    
    template<class T>
    class Teacher{
    
    public:
    
    	Teacher(){
    		cout << "kong constructer" << endl;
    	}
    
    	Teacher(const T& t){
    		cout << "constructer" << endl;
    	}
    
    	T operator()(T data){
    		for (auto i : data){
    			cout << i << endl;
    		}
    		return data;
    	}
    
    };
    
    
    
    
    
    void main(){
    
    	list<int> mylist;
    	for (int i = 0; i < 5; i ++){
    		mylist.push_back(i);
    	}
    
    	/*testFunc(mylist, [](list<int> tlist){
    		for (auto i : tlist){
    			cout << i << endl;
    		}
    		return tlist;
    	});*/
    
    	
    	Teacher<list<int>> temp;
    	testFunc(mylist, temp);
    
    	cin.get();
    }




    展开全文
  • 普通类继承模板类

    千次阅读 2019-04-13 16:24:48
    普通类继承模板类,在继承时实例化了模板类,那么在普通类的构造函数中需要初始化模板类的实例。 如下所示 BASE.HPP #include <iostream> template <typename T> class base{ public: base(T v){ ...

    普通类继承模板类,在继承时实例化了模板类,那么在普通类的构造函数中需要初始化模板类的实例。
    如下所示
    BASE.HPP

    #include <iostream>
    
    template <typename T>
    class base{
    public:
    	base(T v){
    		num  = v;		
    	}
    
    	base(){
    		T a = 0;
    		num = a;
    	}
    	
    	T num;
    
    	T get_num(){
    		return num;	
    	}
    };
    
    
    #include <iostream>
    #include "base.hpp"
    
    
    class data :public base<int>{
    public:
    	data(int arg):base<int>(100)
    	{
    		std::cout<<get_num()<<std::endl;
    		num = arg;
    	}
    	
    	
    };
    
    
    int main()
    {
    	data a(1);
    	std::cout<<a.get_num()<<std::endl;
    
    	base<float> tmp(2.1);
    	std::cout<<tmp.get_num()<<std::endl;
    
    	return 0;	
    }
    

    打印内容如下

    100
    1
    2.1
    
    
    展开全文
  • 模板类继承问题

    2018-06-19 08:33:58
    1. 为何 模板类继承模板类, 子类看不到父类成员 1.1 问题现象 template&lt;typename&gt; struct B { int x; }; template&lt;typename T&gt; struct X : B&lt;T&gt; { void foo() { x ...
  • 在上一篇文章中,介绍了C++中模板类继承的实现。本文补充介绍如何从C++模板类中派生出一个普通类,或者说实现一个普通类A,继承至一个模板类B。 1.实现List基类(模板类) #ifndef LIST_H #define LIST_H #include...
  • 模板类模板通过实例化以后的对象被称为模板类1.类模板定义,类模板中的成员函数定义时,如果在外部定义,则需要加上类模板描述。#include&lt;iostream&gt; #include&lt;vector&gt; using ...
  • c++(类模板继承

    千次阅读 2019-05-03 22:05:53
    根据上一篇博客中举的数组的例子,这篇博客就对其进行继承,再继承一个模板类出来。 下面程序中的searcharray模板就继承了之前的freearray模板类,然后在他的基础上实现对特定数组元素的查找操作: //此模板继承...
  • 模板类继承总结

    千次阅读 2017-05-25 15:21:19
    1.(普通类继承模板类) 2.(模板类继承了普通类(非常常见)) 3.(类模板继承类模板) 4.(模板类继承类模板,即继承模板参数给出的基类) 其中,普通类继承模板类比较简单,如 1 templateclass ...
  • STL模板类继承

    千次阅读 2013-08-06 16:12:54
    1.STL模板类继承符合普通的继承规则  *STL提供的模板类有时并不符合需求,例如,vector类并没有提供下标越界检测。这时便可以通过简单的继承,达到目的。  Example: #include #include #include ...
  • 模板类继承

    万次阅读 2014-03-12 14:45:33
    1.(普通类继承模板类) template class TBase{ T data; …… }; class Derived:public TBase{ …… }; 2.(模板类继承了普通类(非常常见)) class TBase{ …… }; template class TDerived:public TBase{
  • C++中的模板类继承

    2010-04-18 20:04:52
    配套本人博文 C++中模板类继承的实现,在列表中实现了四种不同的排序算法
  • 类模板继承

    千次阅读 2018-07-13 17:20:51
    最近在编程过程中初次遇到...定义模板类如下:template&lt;class T, int dim&gt;class A{public:T a[dim];}定义模板类的派生类:template&lt;class T, int dim&gt;class B : public A&lt;T, dim...
  • C++模板元编程(8)模板类继承

    千次阅读 2021-04-21 00:15:42
    1.普通类继承模板类 大家要区分模板类和类模板的概念,模板类是类模板具体化后得到的类。 template<class T> class Base { public: Base(T data) : data_(data) {} private: T data_; }; class Derived: ...
  • 演示c++ 引用 友员 模板 继承 与对象基本概念用法的代码
  • 1.第一个最简单的类模板案例 #include "mainwindow.h" #include #include #include   templateclass T>  class run { public:   T w;   void show()   { ...
  • 自从`C++11`标准出来之后,就有了关键字`final`可以直接声明一个不能被继承。那么,在此之前如果想要一个不能被继承,可能还需要下一番功夫。
  • C++模板-36-类模板继承和友元.pdf
  • 9.多继承类模板

    万次阅读 2020-03-26 01:05:43
    类模板 1.多态–虚函数 C++中序函数表位于只读数据段(.rodata),也就是C++内存模型中的常量区; 而序函数则位于代码段(.text),也就是C++内存模型中的代码区; 函数的重写/覆盖: (1)不再同一作用域(分别在基类和派生...
  • 给定一个头文件Vec.h,其中有抽象类模板VECROR设计。还有插入运算符重载、抽取运算符重载的普通c++函数...1、将类模板VECTOR作为基类,通过公共继承派生一个新的类模板Vector(向量)和一个新的自定义字符串了String。
  • 继承QVector----模板类继承

    千次阅读 2015-01-15 19:32:25
    对于模板类,一般把接口与实现都放在头文件中(QVector就是这样的,不信翻Qt源码),不然很折腾。 myvector.h #ifndef MYVECTOR_H #define MYVECTOR_H #include #include template class MyVector : public ...
  • c++模板类继承中子类无法访问父类的成员

    千次阅读 多人点赞 2018-03-23 17:58:01
    c++模板类继承中子类无法访问父类的成员 问题:c++模板类继承中子类无法访问父类的成员 解决方法:在子类访问父类时加上父类的前缀或使用this-&gt;调用 c++从入门到放弃,感觉c++了解的越多,就越...
  • c++多重继承模板类继承

    千次阅读 2014-07-11 17:42:52
    在很多大型系统中,c++多重继承
  • 先看下面的第一段程序: //这个是基类 template class BasedClass { private: T data ;...//这个是继承类 template class InheritClass : public BasedClass { private: T temp ; public: InheritClass
  • 类似于函数模板的特化,类模板的特化也是在类模板定义以后,用template来说明一个模板的特化类型,特化的类模板甚至可以定义新的数据成员和成员函数,下面就是一个类模板特化的例子: #include template class A{ ...
  • C++--继承中的类模板语法

    千次阅读 2016-12-08 17:39:44
    模板遇上继承之后会发生什么呢? 写一个简单的测试案例来说明当模板与上继承发生的“”大事件“” #include using namespace std; template class A { public: A(T a) { this->a = a; } T &get() { ...
  • struct NODE//就是这个类模板出错 { V element; NODE *next; NODE *prv; NODE(const V & k):element(k){} }; private: NODE<T> *start; NODE<T> *end; int num; LIST(const LIST &l) {} ...
  • C++模板:函数模板类模板模板继承

    万次阅读 多人点赞 2013-09-13 23:09:29
    C++模板:描述   C++提供一种模板的机制来减少代码重复。比如:对于同一样函数使用不同的数据类型,int,double,char等。C++模板属于“元编程”的范畴。 C++ 模板函数:  1.支持不同数据类型的函数重载: #include ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 265,240
精华内容 106,096
关键字:

继承类的类模板