【贪玩巴斯】C++提高编程，掌握最关键的C++技术！（一）{模板全解！一篇文章学会模板的全部知识！ } //2021-08-13

最新推荐文章于 2021-12-15 15:22:22 发布
最新推荐文章于 2021-12-15 15:22:22 发布
阅读量343 收藏 15
点赞数 3
分类专栏： C++初学笔记（入门、核心、进阶） 初学者笔记 文章标签： c++ 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D16100/article/details/119685499
版权

//  Created by AchesonD16 贪玩巴斯 on 2021/6/4.

//C++提高编程

//本阶段主要针对C++ 泛型编程 和 STL技术 做详细讲解，探讨C++更深层的使用

一、模板

//1.1 模板的概念

//模板就是建立通用的模具，大大提高复用性

//模板的特点：

//模板不可以直接使用，它只是一个框架

//模板的通用并不是万能的

//1.2 函数模板

//C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板

//C++提供两种模板机制:函数模板和类模板

/*

1.2.1 函数模板语法

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>

函数声明或定义

解释：

template —      声明创建模板

typename —     表面其后面的符号是一种数据类型，可以用class代替

T —     通用的数据类型，名称可以替换，通常为大写字母

// 函数模板的例子：

// 交换两个整型函数

#include<iostream>

using namespace std;

// 以下是未用函数模板的例子
//void swapInt(int &a, int &b)

//{

//    int temp = a;

//    a = b;

//    b = temp;

//}

//

 交换两个浮点型函数

//void swapDouble(double &a, double &b)

//{

//    double temp = a;

//    a = b;

//    b = temp;

//}


// 以下是运用函数模板的例子

 // 声明一个模板，并且告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型，typename可以换成classs

template<typename T>
void mySwap(T &a, T &b)

{

    T temp = a;

    a = b;

    b = temp;

}

// 测试函数

void test01()

{
    int a = 10;

    int b = 20; 

    //swapInt(a, b);

    // 利用函数模板交换


    // 两种方式使用函数模板

    // 1、自动类型推导

    // mySwap(a, b);


    // 2、显示指定类型

    mySwap<int>(a, b);  // <int> 声明ab的类型

    
    cout << "a = " << a << endl;

    cout << "b = " << b << endl;


//    double c = 1.1;

//    double d = 2.2;

//

//    swapDouble(c,d);

//    cout << "c = " << c << endl;

//    cout << "d = " << d << endl;

}

总结：

函数模板利用关键字 template

使用函数模板有两种方式：自动类型推导、显示指定类型

模板的目的是为了提高复用性，将类型参数化

*/

/*

//函数模板注意事项

#include <iostream>

using namespace std;


template<typename T> // typename 可以替换成class

void mySwap( T &a, T &b)

{

    T temp = a;

    a = b;

    b = temp;

}


//注意事项：

//1、自动类型推导，必须推导出一致的数据类型 T 才可以使用

void test01()

{

    int a = 10;

    int b = 20;

    char c = 'c';

    mySwap(a, b); // 正确

    //mySwap(a, c);   // 错误 ！ 自动类型推导必须推导出一致的。这里没有推导出一致的！

    cout << "a = " << a << endl;

    cout << "b = " << b << endl;

    

}



//2、模板必须要确定出T的数据类型，才可以使用

template<class T>

void func()

{

    cout << "func 调用" << endl;

}

// 这个函数没有用到class T


void test02()

{

    func<int>(); // 加了一个<int>  给出确定的T的数据类型 , 如果没有那么该test02函数会出错

}



int main()

{

    test01();

    test02();

    system("pause");

    return 0;

}

总结：

使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

*/

//函数模板案例

//案例描述：

//利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序

//排序规则从大到小，排序算法为选择排序

//分别利用char数组和int数组进行测试

// 程序如下：

#include <iostream>

using namespace std;

// 实现交换函数模板

template<typename T>

void mySwap(T &a, T &b)

{

    T temp = a;

    a = b;

    b = temp;

}


// 排序算法

template<typename T>

void mySort( T arr[], int len)

{

    // 从大到小排

    for (int i = 0; i < len; i++)

    {

        int max = i;  // 认定的最大值的下标

        for (int j = i+1; j < len; j++)

        {

            if(arr[max] < arr[j])

            {

                max = j; // 更新最大值下标

            }

        }

        if (max != i)

        {

            //交换max 和 i 元素

            mySwap(arr[max], arr[i]);

        }

    }

}


// 提供打印数组模板

template<typename T>

void printArray(T arr[], int len)

{

    for(int i = 0; i < len; i++)

    {

        cout << arr[i] << " ";

    }

    cout << endl;

}



void test01()

{

    // 测试char 数组

    char charArr[] = "badcfe";

    int num = sizeof(charArr) / sizeof(char);    // 这里是一个小小的点睛之笔

    mySort(charArr, num);

    printArray(charArr, num);

}


void test02()

{

    // 测试int数组

    int intArr[] = { 7, 5, 1, 3, 9, 4, 2, 6, 8};

    int num = sizeof(intArr) / sizeof(int);

    mySort(intArr, num);

    printArray(intArr, num);

}



int main()

{

    test01();

    test02();

    system("pause");

    return 0;

}

/*

普通函数 与 函数模板的区别：

//普通函数与函数模板区别：

//普通函数调用时可以发生自动类型转换（隐式类型转换）

//函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换

//如果利用显示指定类型的方式，可以发生隐式类型转换

#include <iostream>

using namespace std;

// 普通函数与函数模板区别

// 1、普通函数调用可以发生隐式类型转换

// 2、函数模板 用自动类型推导，不可以发生隐式类型转换

// 3、函数模板 用显示指定类型，可以发生隐式类型转换


// 普通函数

int myAdd01(int a, int b)

{

    return a+b;

}


template<class T>

T myAdd02(T &a, T &b)

{

    return a + b;

}



void test01()

{

    int a = 10;

    int b = 20;

    char c = 'c'; // a - 97 c - 99

    cout << myAdd01(a, b) << endl;  // 结果 30

    cout << myAdd01(a, c) << endl;  // 这里输入c的话 会自动类型转换 c - 99 最后结果为 109；


    // 自动类型推导  不会发生隐式类型转换

    cout << myAdd02(a, b) << endl;  // 30

    // cout << myAdd02(a, c) << endl;  //报错

    
    // 显示指定类型  会发生隐式类型转换

    // cout << myAdd02<int>(a, c) << endl; // 报错

    

}





int main()

{

    test01();

}

总结：

建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

*/

/*

// 普通函数与函数模板的调用规则：

// 调用规则如下：

//1、如果函数模板和普通函数都可以实现，优先调用普通函数

//2、可以通过空模板参数列表来强制调用函数模板

 //3、函数模板也可以发生重载

//4、如果函数模板可以产生更好的匹配，优先调用函数模板

//示例如下：

#include<iostream>

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 test01()

{
    // 1、如果函数模板和普通函数都可以实现，优先调用普通函数

    // 注意： 如果告诉编译器——普通函数是有的，但是只是声明没有实现，或者不在当前文件内实现，就会报错找不到

    int a =10;

    int b =20;

    myPrint(a, b);  // 调用的是普通函数
 

    // 2、可以通过空模板参数列表来强制调用函数模板

    myPrint<>(a,b); // 调用函数模板


    // 3、函数模板也可以发生重载

    int c = 30;

    myPrint(a, b, c);  // 调用重载的函数模板


    // 4、如果函数模板可以产生更好的匹配，优先调用函数模板

    char c1 = 'a';   // char 字符 只能用 '' 单引号

    char c2 = 'b';

    myPrint(c1, c2);   // 会调用函数模板，因为匹配度更高

}


int main()

{

    test01();

    system("pause");

    return 0;

    

}

//总结:

//既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性。

*/


模板的局限性：

//局限性：

//模板的通用性并不是万能的、！！！

/*

例如：

template <class T>

void func(T a, T b) {

    a = b;

}

// 在上述代码中，提供的赋值操作，如果传入的a和b是一个数组，就无法实现了。

// 再比如：

template<class T>

void f(T a, T b)

{

    if(a > b)

    {

    ...

    }

}

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

*/

模板的重载：

/*

//代码如下：

#include<iostream>

using namespace std;

#include<string>


class Person

{

public:

    Person(string name,int age)

    {

        this->m_Name = name;

        this->m_Age = age;

    }


    string m_Name;

    int m_Age;

};


// 普通函数模板

template<class T>

bool myCompare(T &a, T &b)

{

    if (a==b)

    {

        return true;

    }

    else

    {

        return false;

    }

}



// 和运算符重载一个作用的 模板中的具体化实现

// 具体化，显示具体化的原型和以template<>开头，并通过名称来指出其类型

// 具体化优先于常规模板



//语法如下：template<> bool myCompare(Person &p1, Person &p2)直接把形参列表的数据类型写出来


template<> bool myCompare(Person &p1, Person &p2)

{

    if(p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)

    {

        return true;

    }

    else

    {

        return false;

    }

}


// 内置数据类型的测试

void test01()

{

    int a = 10;

    int b = 20;

    // 内置数据类型可以直接使用通用的函数模板

    bool ret = myCompare(a, b);

    

    if(ret)

    {

        cout << "a == b" << endl;

    }

    else

    {

        cout << "a!= b" << endl;

    }

}


// 自定义数据类型的测试
void test02()

{

    Person p1("Tom", 10);

    Person p2("Tom", 10);

    //自定义数据类型，不会调用普通的函数模板

    //可以创建具体化的Person数据类型的模板，用于特殊处理这个类型

    bool ret = myCompare(p1, p2);

    if(ret)

    {

        cout << "p1 == p2" << endl;

    }

    else

    {

        cout << "p1 != p2" << endl;

    }

}


int main()

{

    test01();

    test02();


    system("pause");

    return 0;

}

//总结：

//利用具体化的模板，可以解决自定义类型的通用化

//学习模板并不是为了写模板，

而是在STL泛型编程能够运用系统提供的模板。

*/

/*

类模板：

类模板讲解：

// 类模板的作用：

// 建立一个通用类，类中的成员 、数据类型可以不具体制定，用一个虚拟的类型来代表。

//语法：

//template<class T>

//类

//解释：

//template —— 声明创建类的模板

//class —— 表面其后面的符号是一种数据类型，可以用typename代替。

//T —— 通用的数据类型，名称可以替换，通常为大写字母

//示例：

#include <iostream>

#include<string>

using namespace std;

// 类模板

template<class NameType, class AgeType>

class Person

{

public:

    Person(NameType name, AgeType age)

    {

        this->mName = name;

        this->mAge = age;

    }


    void showPerson()

    {

        cout << "name: " << this->mName << " age: " << this->mAge << endl;

    }

public:

    NameType mName;

    AgeType mAge;

};



void test01()

{

    // 指定NameType 为 string 类型，AgeType类型为 int类型

    Person<string, int>p1("吴彦祖", 45);

    p1.showPerson();

}

int main()

{

    test01();

    system("pause");

    return 0;

}

//总结:类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

*/

/*

//类模板和函数模板的区别：

//类模板和函数模板区别主要有两点：

//1、类模板没有自动类型推导的使用方法

//2、类模板在模板参数列表中可以有默认参数

//代码示例如下：

#include <iostream>

#include <string>

using namespace std;


//template<class NameType, class AgeType >  // 原型


// 类模板的参数列表中可以有默认的参数  注意事项:
//    1 <>不能省略
//    2 一个位置使用了默认参数, 其后的所有参数必须使用默认参数(定义类模板时, 也应该在模板参数表
//      中保证第一个使用默认参数的参数后的所有模板参数均匀默认值)

template<class NameType = string, class AgeType = int>
class Person
{

public:
//    Person(NameType name, AgeType age)
   Person(NameType name, AgeType age)
    {

        this->mName = name;

        this->mAge = age;

    }


    void showPerson()

    {

        cout << "name: " << this->mName << " age: " << this->mAge << endl;

    }

public:

    NameType mName;

    AgeType mAge;

};


// 1、类模板没有自动类型推动的使用方式

void test01()

{
//    Person p("吴彦祖", 45); // 错误，类模板使用时候，不可以用自动类型推导

    Person <string, int>p("吴彦祖", 45); // 必须要用显示指定类型

    p.showPerson();
}


//  2、类模板在模板参数列表中可以有默认的参数，但是这样的话 <> 不能少

    void test02()

    {

        Person<>p("吴彦祖",99);

        p.showPerson();

    }


    int main()

    {

        test01();

        test02();


        system("pause");

        return 0;

    }

//总结：

//类模板使用只能用显示指定类型的方式

//类模板中的模板参数列表可以有默认参数

*/

/*

// 类模板中成员函数创建时机：

// 类模板中成员函数和普通类中成员函数创建时机是有区别的：

// 普通类中的成员函数一开始就可以创建

// 类模板中的成员函数在调用时候才创建

#include<iostream>

#include<string>

using namespace std;


class Person1

{

public:

    void showPerson1()

    {

        cout << "Person1 show" << endl;

    }

};


class Person2

{

public:

    void showPerson2()

    {

        cout << "Person2 show" << endl;

    }

};


template<class T>

class MyClass

{

public:

    T obj;

    // 类模板中的成员函数，并不是一开始就创建的，而是在模板调用的时候再生成

    void func1()

    {

        obj.showPerson1();

    }

    void func2()

    {

        obj.showPerson2();

    }

};



void test01()

{

    MyClass<Person1> m; // 类模板使用只能用显示指定类型

    m.func1();

//    m.func2();  // 编译会出错，说明函数调用才会去创建成员函数。

}



int main()

{

    test01();


    system("pause");

    return 0;

}

// 总结：

类模板中的成员函数并不是一开始就创建的，在调用时才会创建

*/

/*

类模板对象做函数参数：

//学习目标：

//类模板实例化出的对象，向函数传参的方式

//一共有三种传入方式

//1、指定传入的类型——直接显示对象的数据类型

//2、参数模板化——将对象中的参数变为模板进行传递

//3、整个类模板化——将这个对象类型 模板化进行传递

// 代码如下：

#include<iostream>

#include<string>

using namespace std;


template<class NameType,class AgeType = int>

class Person

{

public:

    Person(NameType name, AgeType age)

    {

        this->mName = name;

        this->mAge = age;

    }

    void showPerson()

    {

        cout << "name: " << this->mName << " age: " << this->mAge << endl;

    }
    

public:

    NameType mName;

    AgeType mAge;

};

// 函数中， 1、指定传入的类型

void printPerson1(Person<string, int> &p)

{

    p.showPerson();

}

void test01()

{

    Person<string, int >p("吴彦祖", 45);

    printPerson1(p);

}





// 2、参数模板化  // 再设计一个模板

template <class T1, class T2>

void printPerson2(Person<T1, T2> &p)

{

    p.showPerson();

    // 新知识点:可以显示类型的函数 typeid().name()

    cout << "T1的类型为：" << typeid(T1).name() << endl;

    cout << "T2的类型为：" << typeid(T2).name() << endl;

}

void test02()

{

    Person <string, int>p("陈冠希", 24);

    printPerson2(p);

}


// 3、整个类模板化

template<class T>

void printPerson3(T &p)

{

    cout << "T的类型为： " << typeid(T).name() << endl;

    p.showPerson();

}

void test03()

{

    Person<string, int> p("彭于晏", 35);

    printPerson3(p);

}


int main()

{

    test01();

    test02();

    test03();

    

    system("pause");

    return 0;

}

//总结：

//通过类模板创建的对象，可以有三种方式向函数中进行传参

//使用比较广泛的是一种:指定传入的类型

*/

/*

 类模板与继承：

//当类模板碰到继承时候，需要注意以下几点：

//1、当子类继承的父类是一个类模板的时候，子类在声明的时候，要指定出父类中的T的类型

//2、如果不指定，编译器无法给子类分配内存

//3、如果想灵活指定出父类中T的类型，子类也需要变为类模板​​​​​​​

// 代码如下：

#include<iostream>

#include<string>

using namespace std;


template<class T>

class Base

{

    T m;

};

// class Son:public Base // 错误，必须要知道父类中的T的类型，才能继承给子类

//正确写法如下：


class Son:public Base<int>

{
  

};



void test01()

{

    Son s1;

}


// 如果想灵活指定父类中的T类型，子类也需要变模板

template<class T1, class T2>

class Son2:public Base<T2>

{

public:

    Son2()

    {

        cout << "T1的类型为：" << typeid(T1).name() << endl;

        cout << "T2的类型为：" << typeid(T2).name() << endl;

    }

    T1 obj;

};



void test02()

{

    Son2<int, char> S2;

}


int main()

{

    test01();

    test02();

    system("pause");

    return 0;

}

//总结：如果父类是类模板，子类 需要指定出父类中T的数据类型

*/

/*

类模板成员函数类外实现：

代码如下:

#include <iostream>

#include <string>

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;

//    }


public:

    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;

}


// 类内的成员函数类外的实现

// showPerson的实现， 记住 <> 模板参数列表必须写

template<class T1, class T2>

void Person<T1, T2>::showPerson()

{

    cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;

}

void test01()

{

    Person<string, int> p("Tom", 20);

    p.showPerson();

}

int main()

{

    test01();   

    system("pause");

    return 0;

}

//总结：类模板中成员函数类外实现时，需要加上模板参数列表

*/

类模板分文件编写的问题以及结局办法:

// main文件中要包含

/*

//第一种解决办法，直接包含 源文件

#include"person.cpp"

// 第二种解决办法，将.h 和 .cpp中额内容写到一起，并将后缀名改为.hpp文件  —— 类模板用的 约定俗成

// 用法

#include "person.hpp"

代码如下：

#include <iostream>

#include <string>

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;

}


void test01()

{

    Person<string, int> p ("Jerry", 22);

    p.showPerson();

}


int main()

{

    test01();

    system("pause");

    return 0;

}

*/



/*

// 分文件编写如下：




// 先创建person.h
// 以下为person.h 头文件

#pragma once
#include<iostream>
using namespace std;

#include <string>

template<class T1, class T2>
class Person

{

public:

    Person(T1 name, T2 age);

    void showPerson();

    T1 m_Name;

    T2 m_Age;

};




// 创建 person.cpp 文件
// 以下为 person.cpp 文件

#include "person.h"

// 尝试一下类外实现：

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;

}







// 第二种解决办法，将.h 和 .cpp中的内容写到一起，并将后缀名改为.hpp文件  —— 类模板用的 约定俗成

// 创建一个person.hpp 文件



#pragma once

#include<iostream>

using namespace std;

#include <string>


template<class T1, class T2>

class Person

{

public:

    Person(T1 name, T2 age);

    void showPerson();

    T1 m_Name;

    T2 m_Age;

};



// 创建 person.cpp 文件

// 尝试一下类外实现：

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;

}

*/


// 总结： 主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

类模板与友元：

/**

学习目标：

掌握类模板配合友元函数的类内和类外实现

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

*/

代码如下：

/*

#include<iostream>

using namespace std;


// 2、全局函数配合友元 类外实现 -  先做函数模板声明，下方再做函数模板定义，再做友元

template<class T1,class T2> class Person;


// 如果声明了函数模板，可以将实现写到后面，否则需要将实体写到类的前面让编译器提前看到

// template<class T1, class T2> void printPerson2(Person<T1, T2> & p);


template<class T1, class T2>

void printPerson2(Person<T1, T2> & p)

{

    cout << "类外实现 --- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;

}


template<class T1, class T2>

class Person

{
    // 1、 全局函数配合友元， 类内实现

    friend void printPerson(Person<T1, T2> & p)
    {

        cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;

    }

    

    // 全局函数 配合友元 类外实现

    friend void printPerson2<>(Person<T1, T2> & p);

    

public:

    Person(T1 name, T2 age)

    {

        this->m_Name = name;

        this->m_Age = age;

    }

    

private:

    T1 m_Name;

    T2 m_Age;

    

};


// 1、 全局函数在类内实现

void test01()

{

    Person<string, int>p("Tom", 30);

    printPerson2(p);

}



// 2、全局函数在类外实现

void test02()

{

    Person<string, int >p("jerry", 49);

    printPerson2(p);

}



int main()

{

    test01();

    test02();

    
    system("pause");

    return 0;

}

// 总结： 建议全局函数做类内实现，用法简单，而且编译器可以直接识别。

*/

类模板案例：

/*

案例描述: 实现一个通用的数组类，要求如下：

可以对内置数据类型以及自定义数据类型的数据进行存储

将数组中的数据存储到堆区

构造函数中可以传入数组的容量

提供对应的拷贝构造函数以及operator=防止浅拷贝问题

提供尾插法和尾删法对数组中的数据进行增加和删除

可以通过下标的方式访问数组中的元素

可以获取数组中当前元素个数和数组的容量

*/

以下为 myArray.hpp 源文件代码：

//
//  myArray.hpp
//  day_01
//
//  Created by AchesonD16 贪玩巴斯 on 2021/8/6.
//

#ifndef myArray_h
#define myArray_h

#endif /* myArray_h */

#pragma once
#include <iostream>
using namespace std;

template<class T>
class myArray{
public:
    // 构造函数
    myArray(int capacity){
        this->m_Capacity = capacity;
        pAddress = new T[this->m_Capacity];
    }
    // 拷贝构造 const myArray & 为固定格式
    myArray(const myArray & arr){
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->pAddress = new T[this->m_Capacity];
        for(int i = 0; i < this->m_Size; i++){
            // 如果T为对象，而且还包含指针，必须要重载 = 操作符，因为这个等号不是 构造 而是赋值！
            // 普通类型可以直接 = 但是指针类型需要深拷贝
            this->pAddress[i] = arr.pAddress[i];
        }
    }
    
    // 重载 = 操作符 防止浅拷贝问题
    myArray& operator = (const myArray& myarray){   // & 取址符号
        if(this -> pAddress != NULL){
            delete[] this->pAddress;
            this->m_Capacity = 0;
            this->m_Size = 0;
        }
        this->m_Capacity = myarray.m_Capacity;
        this->m_Size = myarray.m_Size;
        this->pAddress = new T[this -> m_Capacity];
        for (int i = 0; i < this->m_Size; i++) {
            this->pAddress[i] = myarray[i];
        }
        
        return *this;
    }
    
    // 重载 [] 操作符 arr[0]
    T& operator [](int index){
        return this->pAddress[index];   // 不考虑越界。用户自己去处理
    }
    
    // 尾插法
    void push_Back(const T & val){
        if(this->m_Capacity == this->m_Size)
        {
            return;
        }
        this->pAddress[this->m_Size] = val;
        this->m_Size ++;
    }
    
    // 尾删法
    void pop_Back()
    {
        if(this->m_Size == 0)
        {
            return;
        }
        this->m_Size--;
    }
    
    // 获取数组容量
    int getCapacity()
    {
        return this->m_Capacity;
    }
    
    // 获取数组大小
    int getSize()
    {
        return this->m_Size;
    }
    
    // 析构
    ~myArray()
    {
        if(this->pAddress != NULL)
        {
            delete[] this -> pAddress;
            this->pAddress = NULL;
            this->m_Capacity = 0;
            this->m_Size = 0;
        }
    }
    
    
    
private:
    T * pAddress;  // 指向一个堆空间，这个空间存储真正的数据
    int m_Capacity; // 容量
    int m_Size;  // 大小
};

以下代码为 cpp 源文件​​​​​​​：

#include "myArray.hpp"

#include <iostream>



void printIntArray(myArray<int>& arr){

    for(int i = 0; i < arr.getSize(); i++){

        cout << arr[i] << " ";

    }

    cout << endl;

}



// 测试内置数据类型

void test01()

{

    myArray<int> array1(10);

    for(int i = 0; i < 10; i++)

    {

        array1.push_Back(i);

    }

    

    cout << "array1打印输出：" << endl;

    printIntArray(array1);

    cout << "array1的大小：" << array1.getSize() << endl;

    cout << "array1的容量：" << array1.getCapacity() << endl;

    

    cout << "-------------------------------------" << endl;

    

    myArray<int> array2(array1);

    array2.pop_Back();

    cout << "array2打印输出：" << endl;

    printIntArray(array2);

    

    cout << "array2的大小：" << array2.getSize() << endl;

    cout << "array2的容量：" << array2.getCapacity() << endl;

}





// 测试自定义数据类型

class Person {

public:

    Person() {}

    Person(string name, int age){

        this->m_Name = name;

        this->m_Age = age;

    }

    

public:

    string m_Name;

    int m_Age;

};



void test02(){

    // 创建数据

    myArray<Person> pArray(10);

    Person p1("孙悟空", 20);

    Person p2("韩信", 30);

    Person p3("林书豪", 40);

    Person p4("梅西", 60);

    Person p5("刘某", 10);

    

    // 插入数据

    pArray.push_Back(p1);

    pArray.push_Back(p2);

    pArray.push_Back(p3);

    pArray.push_Back(p4);

    pArray.push_Back(p5);



   // printIntArray(pArray);

    

    cout << "pArray的大小：" << pArray.getSize() << endl;

    cout << "pArray的容量：" << pArray.getCapacity() << endl;

}



int main()

{

    test01();

    

    test02();

    

    system("pause");

    return 0;

}

贪玩巴斯
关注
专栏目录
【贪玩巴斯】C++提高编程，掌握STL中最关键的容器技术！（二）{33333字，十分钟，一文读懂STL中的Vector、string、deque容器！ } //2021-08-18
D16100的博客
08-18 272
// main.cpp // day_02 // // Created by AchesonD16 贪玩巴斯 on 2021/8/6. /* STL初识 1.1 STL的诞生 长久以来，软件界一直希望建立一种可重复利用的东西 C++的面向对象和泛型编程思想，目的就是复用性的提升 大多情况下，数据结构和算法都未能有一套标准,导致被迫从事大量重复工作 为了建立数据结构和算法的一套标准,诞生了STL STL基本概念 STL(Standard Template Libr...
【贪玩巴斯】C++提高编程，掌握STL中最关键的容器技术~（三）{map、set、list、queue、stack 五大容器一篇解决！} //2021-08-25
D16100的博客
08-25 312
// day_03 // Created by AchesonD16 贪玩巴斯 on 2021/8/19. 1. stack容器 （栈） 1.1 stack 基本概念 栈 概念： stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口，后进先出 栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为 栈中进入数据称为 — 入栈 push 栈中弹出数据称为 — 出栈 pop 1.2 stack 常用接口 功能...
【贪玩巴斯】c++核心编程结课大作业——职工管理系统 ！（九）{全解 详解！} //2021-06-02
D16100的博客
06-02 319
如果有任何问题，可以留言讨论。必定详细解答~ 包含 worker类 workermanager类 employee类 boss类 主要功能封装在workermanager.cpp文件中 worker.hpp 头文件 // // worker.hpp // EmployeeManagementSystem // // Created by AchesonD 贪玩巴斯 on 2021/5/25. // #ifndef worker_hpp #define worker_hp..
【贪玩巴斯】c++核心编程，你需要敲出这些程序 ！（七）{ 多态 全解 详解！} //2021-05-14
D16100的博客
05-15 307
// // main.cpp // _day7 // // Created by AchesonD16 贪玩巴斯 on 2021/5/7. // // 多态 一、多态的基本概念 // 多态的基本概念 //多态是C++ 面相对象三大特性之一 /* 多态分为两类 静态多态： 函数重载 和 运算符重载 属于 静态多态，复用函数名 动态多态： 派生类 和 虚函数 实现运行时 多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段...
【贪玩巴斯】c/c++ 编程竞赛（ACM、蓝桥杯等）每日一练
D16100的博客
04-04 343
第一题 题目： 链接：https://ac.nowcoder.com/acm/problem/50906 来源：牛客网 求 a 的 b 次方对 p 取模的值，其中0≤a,b,p≤109​0≤a,b,p≤109​ 输入描述: 三个用空格隔开的整数a,b和p。 输出描述: 一个整数，表示ab mod p的值。 示例1： 输入 2 3 9 输出 8 我的代码： /* created by AchesonD16 */ #include<iostream> #i..
【贪玩巴斯】c++核心编程，你需要敲出这些程序 ！（八）{C++文件读写 全解 详解！} //2021-05-15
D16100的博客
05-15 366
// // main.cpp // _day8 // // Created by AchesonD16 贪玩巴斯on 2021/5/12. // // 文件操作 一、文件操作基础知识 // 程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放 //通过文件可以将数据持久化 //C++中对文件操作需要包含 头文件 <fstream> //文件类型分为两种： //1、文本文件 - 文件以文本的ASCII码形式存储在计算机中 ...
【贪玩巴斯】c++核心编程，你需要敲出这些程序 ！（一）{ c++内存分区讲解！new操作符！引用详解！}
D16100的博客
04-07 175
// // main.cpp // _day1 // // Created by AcehsonDan 贪玩巴斯 on 2021/4/4. // //c++核心编程 //即C++ 面向对象编程 （是c++中的核心和精髓） 一、内存分区模型 1.内存分区模型 //c++在执行程序时，将内存大方向划分为4个区域。 /* 1、代码区：存放函数体的二进制代码，由操作系统进行管理 2、全局区：存放 全局变量 静态变量 常量 3、栈区：由编译器自动分配释放...
【贪玩巴斯】C++ tips——知识点：to_string()函数
D16100的博客
12-15 1564
C++ tips——知识点：to_string函数to_string()函数 to_string()函数 to_string 函数： 将数字常量转换为字符串， 返回值为转换完毕的字符串 头文件： #include string s = to_string(i); //将整数i转换为字符串表示形式 string to_string (int val); string to_string (long val); string to_string (long long val); string to_string
【贪玩巴斯】c++核心编程，你需要敲出这些程序 ！（六）{继承 的详解！} //2021-05-03
D16100的博客
05-03 295
// // main.cpp // _day6 // // Created by AchesonD16 贪玩巴斯on 2021/4/23. // //继承 //继承是面向对象三大特性之一 // //有些类与类之间存在特殊的关系，例如： //我们发现，定义这些类时，下一级别的成员除了拥有上一级的共性，并且还拥有自己的特性 //这个时候我们可以考虑利用继承的技术，减少重复代码 1、继承的基本语法 //例如我们看到的很多网站中，都有公...
Win8风格自我介绍PPT模板.pptx
最新发布
04-14
【Win8风格自我介绍PPT模板】是一种设计独特的演示文稿模板，专为那些希望以现代、简洁且具有Windows 8操作系统特色的方式展示自我信息的人准备。Windows 8以其大胆的磁贴界面和扁平化设计引领了一股设计潮流，这款...
微软win8风格PPT模板.pptx
02-06
【微软Win8风格PPT模板】是用于创建演示文稿的一种设计模板，它采用了微软Windows 8操作系统的设计元素，如动态磁贴（Live Tiles）和简洁的平面化设计，为用户提供了现代、时尚且专业的展示界面。这款模板适用于商业...
最后一课课件1_精美学习课件ppt
11-23
### 《最后一课》知识点梳理 #### 一、作品背景及作者介绍 - **作品名称**：“最后一课” - **作者简介**： - **都德**（1840～1897），十九世纪法国著名小说家。 - 早期代表作品包括长篇自传体小说《小东西》。 ...
从一个月2500没人要到大厂技术主管的编程之路|我的十年
热门推荐
启舰
03-03 1万+
我们程序员，即便做到CTO，也远没有到拼才华的时候，即使吹上天，也不过是普通人，一些看起来比我们牛逼的人物，只不过在别人选择安逸的时候，他选择了拼搏而已。 我也一样，曾几何时，我也是2500一个月都找不到工作的青涩少年，也是帮别人发传单、做门童，满地找兼职的学生仔。 这篇文章很长，近7000字。我选取了我人生中的几个重要经历和抉择，这些事件，持续影响了我的一生，希望对大家有所启发。 通过这篇文章，我只想让大家知道，我跟大家一样都只是普通人，也曾经处在比大家更差的阶段，只是靠坚持和毅力，把一手烂牌打得看
【贪玩巴斯】传感器与检测技术 （一）「金属传感器三大重要传感器——电感、电容与振弦式」2021-09-28
D16100的博客
09-28 1582
金属传感器1. 引言2. 电阻式传感器1.概论2.应变式电阻传感器3. 热电阻3.电感式传感器4.电容式传感器↑差动式必考↑5.振弦式传感器 1. 引言 金属的重要性 信息传感与能量传感 金属键 2. 电阻式传感器 1.概论 将被测量的变化转换为传感器电阻值的变化，再经由一定的测量电路实现对测量结果的输出。 主要包括： 应变式电阻传感器 热电阻 2.应变式电阻传感器 - 应变是物体在外部压力或拉力作用下发生形变的现象。 金属电阻应变片 现在已经不常用 弹性元件： 在测量过程中，具有弹性应变
【贪玩巴斯】Linux笔记记录Day1//纯新手入门基于ubantu
D16100的博客
07-19 1003
tab键可以自动补全 *******************pwd 查看当前所处目录 ———————————————————————————————————————————————————————— *******************ls查看该文件下的所有文件夹 ls -a 查看所有隐藏文件 ls -l 显示所有详细的信息 ls -lh 可以显示所有详细的信息加上文件大小 .[文件名] .开头的为隐藏文件 . 代表当前目录 .. 代表上一级目录 ls *a* *可以代替很多字符...
【贪玩巴斯】JAVA初学笔记——chapter2 JAVA基本语法上，关键字保留字标识符，变量以及变量的定义使用//2021-1-23
D16100的博客
01-23 359
一、关键字和保留字 1.关键字 定义：被JAVA赋予了特殊含义，用作专门用途的字符串（单词） 特点：关键字中的所有字母都是小写 2.保留字 现有的JAVA尚未使用 但以后版本可能会作为关键字使用 尽量避免使用 goto const 3.标识符 identifier java 对各种变量 方法 类等要素命名时用的字符序列称为标识符 技巧：凡是自己起名字的地方都叫标识符 标识符的定义规则 参考截图 4. /* 标识符的使用 1.标识符：凡是自己起名字的地方都叫做标识符 ...
【贪玩巴斯】JAVA初学笔记——chapter1 JAVA基础知识//2020-11-03
D16100的博客
11-03 358
第一点： java 必须区分大小写 在CMD中找到 java文件 输入指令为 javac HelloWorld.java //这是编译 java HelloWorld //这是执行 即可（其中java那一行 必须是和程序中class的一样） 错误: 找不到或无法加载主类 HelloWorld.java 我在这里犯的错误是 输入 java HelloWorld.class 此处不需要class ！！ 当然，也有可能是环境变量配置错误 mingzi.java ...
【贪玩巴斯】JAVA初学笔记——chapter2 JAVA基本语法下，运算符介绍//2021-1-24
D16100的博客
01-24 349
1.运算符 运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。 有以下基本的运算符：算术，赋值，比较（关系），逻辑，位运算符，三元运算符 2.算术运算符的使用 a.算术运算符.png b.算术运算符自增自减练习.png 运算符之一：算术运算符+ - + - * / % 取模（取余） （前）++ （后）-- （前）-- （后）-- 连接符号：+ 先加减后乘除 // 注意java中除号...
华为编程规范详解：提升企业开发效率的关键要素
华为编程规范和范例详细概述了华为内部在软件开发过程中遵循的一系列标准和最佳实践，旨在提升代码质量和团队协作效率。本文档主要关注以下几个关键领域： 1. 排版： - 华为倡导采用缩进风格编写代码，每个级别的...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贪玩巴斯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值