C++模板的一些基础知识

最新推荐文章于 2023-02-10 10:07:32 发布
最新推荐文章于 2023-02-10 10:07:32 发布
阅读量224 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanzonghao/article/details/117654271
版权

一.函数模板

可看出就是将函数返回类型和形参类型去掉。

1.代码1

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

template<typename T>
void swap_(T& a, T& b ){
    T temp = a;
    a = b;
    b = temp;
}
int main()
{

    //1.自动类型推导 必须要一致的数据类型才可用
    int a1 = 10, b1 = 20;
    cout<<a1<<" "<<b1<<endl;
    swap_(a1, b1);
    cout<<a1<<" "<<b1<<endl;

    float a2 = 10.01, b2 = 20.55;
    cout<<a2<<" "<<b2<<endl;
    swap_(a2, b2);
    cout<<a2<<" "<<b2<<endl;

    //2.显示指定类型
    swap_<int>(a1, b1);
    cout<<a1<<" "<<b1<<endl;
    swap_<float>(a2, b2);
    cout<<a2<<" "<<b2<<endl;
    return 0;
}

有两种使用方式，一个是自动类型推导(必须要一致的数据类型才可用)，一个是显示指定类型。

2.代码2

将类型作为参数,用template修饰函数模板,解决不同类型函数但实现逻辑一样的问题

#include <iostream>
using namespace std;


template <typename T>//函数模板
void display(T a)
{
    cout<<"a:"<<a<<endl;
    cout<<"======="<<endl;
}

template <typename T,typename S>//函数模板
void display(T t, S s)
{   
    cout<<"t:"<<t<<endl;
    cout<<"s:"<<s<<endl;
    cout<<"======="<<endl;
}

template <typename T,int KSize>//函数模板
void display(T a)
{
    for (int i=0;i<KSize;i++)
    {
        cout<<"a:"<<a<<endl;
    }

}

int main()
{   
    display<int>(10);//模板函数
    display<double>(10.89);//模板函数

    display<int,float>(11,12.11);//模板函数


    display<int, 5>(11);
    return 0;
}

3.代码3

选择排序，降序排序

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

template<typename T>
void swap_(T& a, T& b){
    T temp = a;
    a = b;
    b = temp;
}

//从大到小排序
template<typename T>
void sort_(T& arr){
    int n = sizeof(arr) / sizeof(arr[0]);
    for(int i = 0; i < n; i++){
        int index = i;
        for(int j = i + 1; j < n; j++){
            if(arr[index] < arr[j]){
                index = j;
            }
        }
        if(index != i){
            swap_(arr[index], arr[i]);
        }
    }
}
template <typename T>
void printArr(T& arr){
    int n = sizeof(arr) / sizeof(arr[0]);
    for(int i = 0; i < n; i++ ){
        cout<<arr[i]<<" ";
    }
    cout<<endl;
}
int main()
{
//    test06();
    char charArr[] =  "bdfdsskn";
    sort_(charArr);
    printArr(charArr);

    int intArr[] =  {6, 7, 4, 6, 8, 2, 3, 7};
    sort_(intArr);
    printArr(intArr);
    return 0;
}

4.普通函数和模板函数的调用规则

4.1如果函数模板和普通函数都可以调用，优先调用普通函数

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

//
void myPrint(int a, int b){
    cout<<"调用的普通函数"<<endl;
}

template <typename T>
void myPrint(T a, T b){
    cout<<"调用的函数模板"<<endl;
}
void test06(){
   int a = 10, b = 20;
   //如果函数模板和普通函数都可以调用，优先调用普通函数
   myPrint(a, b);
}
int main()
{
    test06();
    return 0;
}

4.2通过空模板参数列表，强制调用函数模板

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

//
void myPrint(int a, int b){
    cout<<"调用的普通函数"<<endl;
}

template <typename T>
void myPrint(T a, T b){
    cout<<"调用的函数模板"<<endl;
}
void test06(){
   int a = 10, b = 20;
  // 通过空模板参数列表，强制调用函数模板
   myPrint<>(a, b);
}
int main()
{
    test06();
    return 0;
}

4.3重载函数模板

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

//
void myPrint(int a, int b){
    cout<<"调用的普通函数"<<endl;
}

template <typename T>
void myPrint(T a, T b){
    cout<<"调用的函数模板"<<endl;
}

template <typename T>
void myPrint(T a, T b, T c){
    cout<<"调用的重载函数模板"<<endl;
}
void test06(){
   int a = 10, b = 20;
  // 通过 空模板参数列表，强制调用模板函数
   myPrint<>(a, b);
   myPrint<>(a, b, 100);
}
int main()
{
    test06();
    return 0;
}

4.4 如果函数模板能够产生更好的匹配，优先使用函数模板

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

//
void myPrint(int a, int b){
    cout<<"调用的普通函数"<<endl;
    cout<<"a:"<<a<<endl;
    cout<<"b:"<<b<<endl;
}

template <typename T>
void myPrint(T a, T b){
    cout<<"调用的函数模板"<<endl;
    cout<<"a:"<<a<<endl;
    cout<<"b:"<<b<<endl;
}

template <typename T>
void myPrint(T a, T b, T c){
    cout<<"调用的重载函数模板"<<endl;
    cout<<"a:"<<a<<endl;
    cout<<"b:"<<b<<endl;
    cout<<"c:"<<c<<endl;
}
void test06(){
   int a = 10, b = 20;
   char c1 = 'a';
   char c2 = 'b';
  // 优先将T推导为char 类型
   myPrint(c1, c2);
}
int main()
{
    test06();
    return 0;
}

可看出优先将T转换成char,而不是将char字符一个一个转换成int类型。 

二.类模板

类模板语法和函数模板语法很接近,都是先声明模板出来。

与函数模板差异

1.代码1:

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

template <class NameType, class AgeType>
class Person{
public:
    Person(NameType name, AgeType age){
        this->m_Name = name;
        this->m_Age = age;
    }
    void showPerson(){
        cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;
    }
    NameType m_Name;
    AgeType m_Age;
};

void test06(){
   Person<string, int> p1("lining", 13);
   p1.showPerson();
}
int main()
{
    test06();
    return 0;
}

 

MyArray.h

#ifndef MYARRAY_H
#define MYARRAY_H
#include <iostream>
using namespace std;

template <typename T, int KSize, int KVal>//T就是要定义的类型

class MyArray
{
    public:
        MyArray();
        ~MyArray()
        {
            delete []m_pArr;
            m_pArr=NULL;
        };
        void display();
    private:
        T *m_pArr;
};

template <typename T,int KSize, int KVal>//函数定义时 一定要写
MyArray<T, KSize, KVal>::MyArray()
{
    m_pArr = new T[KSize];
    for (int i=0;i<KSize;i++)
    {
        m_pArr[i] = KVal;
    }
}

template <typename T,int KSize, int KVal>//函数定义时 一定要写
void MyArray<T, KSize, KVal>::display()
{
    for (int i=0;i<KSize;i++)
    {
        cout<<"m_pArr[i]:"<<m_pArr[i]<<endl;
    }
}

#endif

demo.cpp

#include <iostream>
#include <string>
#include "MyArray.h"
using namespace std;

int main()
{   
    
    MyArray<int, 5, 6> arr;//每个元素都是6共5个元素的数组
    arr.display();
    return 0;
}

​

2.与函数模板差异

1.类模板没有自动推导方式

2.类模板中的参数列表可以有默认类型

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;
//类模板中的参数列表可以有默认类型
template <class NameType, class AgeType = int>
class Person{
public:
    Person(NameType name, AgeType age){
        this->m_Name = name;
        this->m_Age = age;
    }
    void showPerson(){
        cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;
    }
    NameType m_Name;
    AgeType m_Age;
};

void test06(){
//   Person p1("lining", 13); //错误的
//   Person<string, int> p2("lining", 13);
    Person<string> p2("lining", 13); //有默认类型所以这里可以省去int
    p2.showPerson();
}
int main()
{
    test06();
    return 0;
}

3.类模板中成员函数和普通类成员函数创建方式

因为不知道是啥类型, 类模板中的成员函数在调用时才创建

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;
//类模板中的成员函数在调用时才创建 (因为不知道是啥类型)
//普通类中的成员函数一开始就创建
class Person1{
public:
    void showPerson1(){
        cout<<"showPerson1()"<<endl;
    }
};

class Person2{
public:
    void showPerson2(){
        cout<<"showPerson2()"<<endl;
    }
};
template<class T>
class Myclass{
public:
    T obj;
    //类模板中的成员函数
    void func1(){
        obj.showPerson1();
    }
    void func2(){
        obj.showPerson2();
    }
};
void test06(){
    Myclass<Person1> m;
    m.func1();
    m.func1();
}

int main()
{
    test06();
    return 0;
}

4.类模板对象做函数参数

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;
//类模板对象做函数参数
template<class T1, class T2>
class Person{
public:
    Person(T1 name, T2 age){
        this->m_Name = name;
        this->m_Age = age;
    }
    void showPerson(){
        cout<< "姓名: " << this->m_Name <<" 年龄: "<< this->m_Age <<endl;
    }
    T1 m_Name;
    T2 m_Age;
};

//1.指定传入类型 (最常用)
void printPerson1(Person<string, int>&p){
    p.showPerson();
}
//2.参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>&p){
    p.showPerson();
    cout<<"T1类型: "<<typeid(T1).name()<<endl;
    cout<<"T2类型: "<<typeid(T2).name()<<endl;
}
//3.整个类模板化
template<class T>
void printPerson3(T &p){
    p.showPerson();
    cout<<"T类型: "<<typeid(T).name()<<endl;
}
void test06(){
    Person<string, int>p("limin", 100);
    printPerson1(p);
    printPerson2(p);
    printPerson3(p);
}

int main()
{
    test06();
    return 0;
}

5.类模板与继承

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

template<class T>
class Base{
public:
    T m;
};
//class Son1:public Base{ //错误的，必须要知道父类中的T类型,才能继承给子类
class Son1:public Base<int>{

};
template<class T1, class T2>
class Son2:public Base<T2>{ //如果想灵活指定父类中的T类型，子类也需要变类模板
public:
    Son2(){
        cout<<" T1类型: "<<typeid(T1).name()<<endl;
        cout<<" T2类型: "<<typeid(T2).name()<<endl;
    }
    T1 obj;
};

void test06(){
    Son1 s1;
    Son2<int, char> s2;
}

int main()
{
    test06();
    return 0;
}

6.类模板成员函数类外实现

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

//类模板成员函数类外实现
template<class T1, class T2>
class Person{
public:
    Person(T1 name, T2 age);
    //类内实现构造函数
//    Person(T1 name, T2 age){
//        this->m_Name = name;
//        this->m_Age = age;
//    }
//    void showPerson(){
//        cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
//    }
    void showPerson();
    T1 m_Name;
    T2 m_Age;
};
//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this->m_Name = name;
    this->m_Age = age;
}
//成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){
    cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
}
void test06(){
    Person<string, int>p("limin", 100);
    p.showPerson();
}

int main()
{
    test06();
    return 0;
}

7.类模板类分文件编写

7.1.第一种方式：因为类模板成员函数一开始是不会创建的，所以包含.h头文件不会创建类模板成员函数，导致链接阶段无法找到。而改为#include .cpp就可以看见.h成员函数和实现方式.

demo.cpp

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
//#include "Person.h" //错误不能调用
#include "Person.cpp" //改为.cpp文件就行
//#include "Person.hpp" //改为.hpp文件就行 里面包含函数声明与实现
using namespace std;

void test06(){
    Person<string, int>p("limin", 100);
    p.showPerson();
}

int main()
{
    test06();
    return 0;
}

Person.h

#pragma once //防止头文件重复包含
#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

//类模板成员函数类外实现
template<class T1, class T2>
class Person{
public:
    Person(T1 name, T2 age);
    void showPerson();
    T1 m_Name;
    T2 m_Age;
};

Person.cpp

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
#include "Person.h"
using namespace std;
//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this->m_Name = name;
    this->m_Age = age;
}
//成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){
    cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.4.1)
project(Infantry)
add_definitions(-std=c++11)
set(CMAKE_BUILD_TYPE Debug)
set(SRC_LIST demo.cpp Person.cpp Person.h)
#set(SRC_LIST demo.cpp Person.hpp)
add_executable(demo ${SRC_LIST})

7.2函数声明和实现都在.hpp。

Person.hpp 

#pragma once //防止头文件重复包含
#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

//类模板成员函数类外实现
template<class T1, class T2>
class Person{
public:
    Person(T1 name, T2 age);
    void showPerson();
    T1 m_Name;
    T2 m_Age;
};
//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
    this->m_Name = name;
    this->m_Age = age;
}
//成员函数类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson(){
    cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
}

demo.cpp 

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
//#include "Person.h" //错误不能调用
//#include "Person.cpp" //改为.cpp文件就行
#include "Person.hpp" //改为.hpp文件就行 里面包含函数声明与实现
using namespace std;

void test06(){
    Person<string, int>p("limin", 100);
    p.showPerson();
}

int main()
{
    test06();
    return 0;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.4.1)
project(Infantry)
add_definitions(-std=c++11)
set(CMAKE_BUILD_TYPE Debug)
#set(SRC_LIST demo.cpp Person.cpp Person.h)
set(SRC_LIST demo.cpp Person.hpp)
add_executable(demo ${SRC_LIST})

8.类模板配合友元函数的类内和类外实现

8.1.全局函数类内实现

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

template<class T1, class T2>
class Person{
    //全局函数 类内实现
    friend void printPerson(Person<T1, T2> p){
        cout<<" 姓名: "<<p.m_Name<< " 年龄: " <<p.m_Age<<endl;
    }
public:
    Person(T1 name, T2 age){
        this->m_Name = name;
        this->m_Age = age;
    }
//    void showPerson(){
//        cout<<" 姓名: "<<this->m_Name<< " 年龄: " <<this->m_Age<<endl;
//    }
private:
    T1 m_Name;
    T2 m_Age;
};
void test06(){
    //全局函数类内实现的测试
    Person<string, int>p("limin", 100);
    printPerson(p);
}

int main()
{
    test06();
    return 0;
}

8.2 全局函数类外实现

如果全局函数是类外实现的话 需要编译器提前知道这个函数的存在

 

9.案例

MyClass.hpp

#pragma once //防止头文件重复包含
#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
using namespace std;

//类模板成员函数类外实现
template<class T>
class MyArray{
public:
    //有参构造
    MyArray(int capacity){
        cout<<"调用构造函数"<<endl;
        this->m_capacity = capacity;
        this->m_size = 0;
        this->pAddress = new T[this->m_capacity]; //开辟堆区空间
    }
    //拷贝构造函数
    MyArray(const MyArray<T>& arr){
        cout<<"调用拷贝构造函数"<<endl;
        this->m_capacity = arr.m_capacity;
        this->m_size = arr.m_size;

        this->pAddress = new T[arr.m_capacity];//深拷贝
        //将arr中的数据拷贝过来
        for(int i=0; i<this->m_size; i++){
            this->pAddress[i] = arr.pAddress[i];
        }
    }
    //尾插法
    void PushBack(const T& value){
        //先判断是否等于大小
        if(this->m_capacity == this->m_size){
            return;
        }
        this->pAddress[this->m_size] = value; //尾插法
        this->m_size++; //更新数组大小
    }
    //尾删法
    void PopBack(){
        //让用户访问不了最后一个元素
        if(this->m_size == 0){
            return;
        }
        this->m_size--; //更新数组大小
    }
    //通过下标方式访问数组中元素
    T& operator[](int index){
        return this->pAddress[index];
    }
    //返回数组容量
    int getCapacity(){
        return this->m_capacity;
    }
    //返回数组大小
    int getSize(){
        return this->m_size;
    }
    //operator= 也是防止浅拷贝
    MyArray& operator=(const MyArray<T>& arr){
        cout<<"调用operator= 函数"<<endl;
        //先判断原来堆区是否与数据，如果有先释放
        if(this->pAddress != NULL){
            delete []this->pAddress;
            this->pAddress = NULL;
            this->m_capacity = 0;
            this->m_size = 0;
        }
        //深拷贝
        this->m_capacity = arr.m_capacity;
        this->m_size = arr.m_size;
        this->pAddress = new T[arr.m_capacity];//深拷贝
        //将arr中的数据拷贝过来
        for(int i=0; i<this->m_size; i++){
            this->pAddress[i] = arr.pAddress[i];
        }
        return *this;
    }
    virtual ~MyArray(){
        cout<<"调用析构函数"<<endl;
        if(this->pAddress != NULL){
            delete []this->pAddress;
            this->pAddress = NULL;
        }
    }
private:
    int m_capacity;
    int m_size;
    T* pAddress; //指针指向堆区开辟的真实数组
};

demo.cpp

#include <iostream>
#include <vector>
#include <string>
#include <typeinfo>
#include <algorithm>
#include <map>
#include <fstream>
#include "MyClass.hpp"
using namespace std;

void test06(){
    MyArray<int> arr1(20);
    MyArray<int> arr2(arr1);
    MyArray<int> arr3(10);
    arr3 = arr1;
    for(int i=0; i<5; i++){
        arr1.PushBack(i + 10);
    }
    cout<<" ==before arr1.getCapacity(): "<<arr1.getCapacity()<<endl;
    cout<<" ==before arr1.getSize(): "<<arr1.getSize()<<endl;
    for(int i=0; i<arr1.getSize(); i++){
        cout<<"before arr1[i]: " <<arr1[i]<<endl;
    }
    arr1.PopBack();
    arr1.PopBack();
    cout<<" ==after arr1.getCapacity(): "<<arr1.getCapacity()<<endl;
    cout<<" ==after arr1.getSize(): "<<arr1.getSize()<<endl;
    for(int i=0; i<arr1.getSize(); i++){
        cout<<"after arr1[i]: " <<arr1[i]<<endl;
    }
}
class Person{
public:
    Person(){};
    Person(string name, int age){
        this->m_Name = name;
        this->m_Age = age;
    };
    string m_Name;
    int m_Age;
};

void printPersonArray(MyArray<Person>& arr){
    for(int i=0; i<arr.getSize(); i++){
        cout<<" 姓名: "<<arr[i].m_Name<< " 年龄: "<<arr[i].m_Age<<endl;
    }
}
//测试自定义类型
void test07(){
    MyArray<Person> arr(10);
    Person p1("Damin",100);
    Person p2("Tony",70);
    Person p3("Tom",50);
    Person p4("Jarry",10);
    Person p5("Dalin",20);
    arr.PushBack(p1);
    arr.PushBack(p2);
    arr.PushBack(p3);
    arr.PushBack(p4);
    arr.PushBack(p5);
    printPersonArray(arr);
    cout<<" ==arr1.getCapacity(): "<<arr.getCapacity()<<endl;
    cout<<" ==arr1.getSize(): "<<arr.getSize()<<endl;
}

int main()
{
//    test06();
    test07();
    return 0;
}

测试int类型:

测试自定义类型Person:

参考：

https://www.bilibili.com/video/BV1et411b73Z?p=175&spm_id_from=pageDriver

薛定谔的智能
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++入门基础知识总结
08-16
C++入门基础知识总结 C++是基于 C 语言而产生的，它既可以进行 C 语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。C++的历史版本可以追溯到1982年，...
C++学习笔记:模板
qq_42309130的博客
03-27 162
C++学习笔记:模板1.函数模板2.类模板2.1类模板注意事项 模板分为函数模板与类模板。 1.函数模板 函数模板可以建立一个通用的函数，其返回值和参数的类型无需提前确定，用一个虚拟的类型代表。 语法： template<typename T> //函数声明或定义 //template:表明创建一个模板 //typename:表明后面是一种数据类型 //T:通用数据类型 例程： #include <iostream> #include <string> using n
《C++ Primer》第16章 16.5节习题答案
chenyijun的专栏
11-02 249
《C++ Primer》第16章 模板与泛型编程 16.5节模板特例化 习题答案 练习16.62：定义你自己版本的hash<Sales_data>，并定义一个Sales_data对象的unordered_multiset。将多条交易记录保存到容器中，并打印其内容。 【出题思路】 本题练习类模板特例化。 【解答】 #ifndef PROGRAM16_62_SALES_DATA_H #define PROGRAM16_62_SALES_DATA_H #include <str
c++中动态数组vector的使用方法
weixin_45962741的博客
01-31 1148
如果要使用vector，需要头文件#include< vector > 1、vector容器内元素的访问： ①通过下标进行访问： 这种访问和正常的数组类似，只是需要注意的是，需要用push_back将元素放入数组中； #include <iostream> #include <vector> using namespace std; int main() { vector<int >v; for(int i=0;i<5;i++){
Effective C++条款42 了解typenam的双重意义
zion--6135的博客
01-25 488
1. 从属名称与非从属名称 如果tempalte内某个名称依赖于某个template参数，我们称这个参数为从属名称(dependent names) 比如C::const_iterator这个参数类型就是从属名称，依赖于C的类型。 如果不依赖任何其他参数，称为非从属名称(non dependent names) 这就是具体的，不依赖其他类型的参数类型：比如int ,float 这种具体的。 2. 传递模板类型的从属名称参数需要在参数前加上typename 传递带typename的参数：如p..
918c++ 容易混淆程序结果输出题
weixin_43744732的博客
11-05 1609
#include<iostream> using namespace std; class Base{ public: ~Base(){ cout<<"BASE "; } }; class Derived:public Base{ public: ~Derived(){ cout<<"DERIVED "; } }; int main(){ Derived d; return 0; } 这里考察的是继承的析构函数执行顺序是先到自己然后到同类（如果有
C++基础课件，讲述C++基础知识
最新发布
06-20
本基础课件旨在全面介绍C++的基础知识，帮助初学者理解和掌握C++编程的基本概念和技术。 课件内容可能涵盖以下几个关键知识点： 1. **C++简介**：介绍C++的历史、特点和适用领域，以及与C语言的区别。 2. **基本...
C++模板库基础学习
12-09
在这里，我们将深入探讨C++模板库的基础知识，特别是STL的元素、迭代器、函数对象、适配器和容器。 首先，我们来谈谈模板。模板是C++中的一个关键特性，允许我们定义通用函数和类。它可以用于创建泛型代码，这意味...
c++基础知识
04-01
本压缩包文件“c++基础知识.chm”提供了一个全面的学习C++基础知识的资源，对于初学者和有经验的程序员来说都是宝贵的参考资料。 首先，C++的基础知识包括语法和概念，这是理解和编写C++程序的基础。语法方面，C++...
C++基础知识总结（持续更新）
06-14
C++小白，新手
C++:模板的分离编译问题
Taopper的博客
03-07 555
存在问题的代码 test.h #include <iostream> using namespace std; template<class T1,class T2> void func(T1 t1,T2 t2); test.cpp #include "test.h" using namespace std; template<class T1,class T2> void func(T1 t1,T2 t2) { cout<<t1<&
详解C++中经常看到的#include ＜iostream＞ using namespace std；
热门推荐
昊虹AI笔记
03-15 1万+
在cpp文件中，我们经常看到#include &lt;iostream&gt; using namespace std; 这两句连用。问题来了对于从C切换到C++的程序员而言为啥iostream 不写成iostream.h？ 答：在C++引入名字空间的含义之前，都是用#include&lt;iostream.h&gt;这样的写法的，因为要包含进来的头文件名就是iostream.h。标准C++引...
C++之模板
gxy的博客
02-10 156
模板能够使开发人员快速建立具有类型安全的类库集合和函数集合，大大方便了大规模软件开发。
C++类模板
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-09 1074
类模板 1.3.1 类模板语法 类模板作用： 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 类 解释： template — 声明创建模板 typename — 表面其后面的符号是一种数据类型，可以用class代替 T — 通用的数据类型，名称可以替换，通常为大写字母 示例： #include <string> //类模板 template<class NameType, c
C++实验7
qq_62105951的博客
12-19 1014
#include <iostream> using namespace std; class Complex { public: double real; double imag; Complex(double r = 0, double i = 0); void print(); Complex operator+(Complex c); Complex operator*(Complex c); }; Complex::Complex(dou.
C++ 模板 泛型编程
weixin_41111116的博客
07-03 417
C++ 模板
c++填空题
bless_my_head的博客
07-10 7333
5-1 阅读下面的程序，完成其中复制构造函数的代码。 #include <iostream> using namespace std; class CAT { public: CAT(); CAT(const CAT&); ~CAT(); int GetAge() const { return *itsAge; } void SetAge(int age){ *itsAg
C++异常
一首小夜曲
08-07 557
异常是指存在于运行时的反常行为，这些行为超出了函数正常功能的范围。 所以在程序的某部分检测到一个它无法处理的问题时，需要用到异常处理。 首先我们先贴代码#include "stdafx.h" #include <iostream> using namespace std;template <class T> class Vector { public: Vector(int);
C++踩坑
weixin_44716147的博客
01-17 236
#include <iostream> #include <string> using namespace std; int main() { cout << "你好" << endl; system("pause"); return 0; }
深入浅出C++模板基础
文章的后续部分将深入探讨更高级和有趣的模板话题，以及关于STL（标准模板库）的一些知识。STL是一组基于模板的库，包括容器（如vector和list）、迭代器、算法和函数对象，极大地提高了C++的效率和可读性。 C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值