c++学习笔记七

最新推荐文章于 2024-04-16 10:16:13 发布
最新推荐文章于 2024-04-16 10:16:13 发布
阅读量156 收藏
点赞数
分类专栏： c/C++ 文章标签： c++ 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chxchxkkk/article/details/115198903
版权

1.3.5 类模板与继承
        当类模板碰到继承时，需要注意以下几点：
        》当子类继承父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
        》如果不指定，编译器无法给子类分配内存
        》如果想灵活指定出父类中的T类型，子类也需变为类模板
        示例：

//类模板与继承
#include <iostream>
using namespace std;

template<class T>
class Base
{
    public:
   
    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(void)
{
    test01();
    test02();

    system("pause");
    return 0;
}

1.3.6 类模板成员函数的类外实现
        类模板中成员函数类外实现时，需要加上模板参数列表
        示例：

//类模板成员函数类外实现
#include <iostream>
#include <string>
using namespace std;

template<class T1, class T2>
class Person
{
    public:
    Person(T1 name, T2 age);
    /*{
        this->m_Age = age;
        this->m_Name = name;
    }*/

    void showPerson();
    /*{
        cout << "姓名： " << this->m_Name << " "
            << "年龄： " << this->m_Age << endl;
    }*/

    T1 m_Name;
    T2 m_Age;
};

//构造函数类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    this->m_Age = age;
    this->m_Name = name;
}

//成员函数的类外实现
template<class T1, class T2>
void Person<T1,T2>::showPerson()
{
    cout << "姓名： " << this->m_Name << " "
        << "年龄： " << this->m_Age << endl;
}


void test()
{
    Person<string, int> s1("老王", 35);
    s1.showPerson();
}

int main(void)
{
    test();
   
    system("pause");
    return 0;
}

1.3.7 类模板分文件编写
        问题：
        类模板中成员函数创建时机是在调用时才创建，导致分文件编写时链接不到
        解决：
        》解决方式1：直接包含.cpp源文件
        》解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp,hpp是约定的名称，并不是强制
       
        示例：

-----------------------       
        person.hpp:
-----------------------

#pragma once
#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_Age = age;
    this->m_Name = name;
}

//成员函数的类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
    cout << "姓名： " << this->m_Name << " "
        << "年龄： " << this->m_Age << endl;
}

------------------------------------       
        main.cpp
------------------------------------

//类模板分文件编写问题及解决

#include <iostream>

//解决方法一，直接包含源文件
//#include "person.cpp"  

//第二种解决方式，将.h和.cpp中的内容写到一起，将后缀改为.hpp
#include "person.hpp"
using namespace std;

void test()
{
    Person<string, int>p("老五", 25);
    p.showPerson();
}

int main(void)
{
    test();
   
    system("pause");
    return 0;
}

1.3.8 类模板与友元
        掌握类模板配合友元函数的类内和类外实现
        》全局函数类内实现--直接在类内声明友元即可
        》全局函数类外实现--需要提前让编译器知道全局函数的存在
        总结：建议全局函数类内实现，用法简单，而且编译器可以直接识别
        示例：

#include <iostream>
#include <string>
using namespace std;

//提前让编译器知道
template<class T1, class T2>
class Person;

//通过全局函数打印Person信息
//全局函数类外实现
template<class T1, class T2>
void PrintPerson2(Person<T1, T2> p)
{
    cout << "类外实现" << endl;
    cout << "姓名：" << p.m_Name << " " << "年龄： " << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
    public:
    Person(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    //全局函数类内实现
    friend void PrintPerson(Person<T1, T2> p)
    {
        cout << "姓名：" << p.m_Name << " " << "年龄： " << p.m_Age << endl;
    }

    //全局函数类外实现 加空模板列表
    //提前让编译器知道
    friend void PrintPerson2<>(Person<T1, T2> p);
  
    private:
    T1 m_Name;
    T2 m_Age;
};



//全局函数类内实现
void test01()
{
    Person<string, int>p("老王", 30);
    PrintPerson(p);

    Person<string, int>p1("小李", 20);
    PrintPerson2(p1);
}

int main(void)
{
    test01();
   
    system("pause");
    return 0;
}

1.3.9 类模板案例
        实现一个通用的数组类，要求如下：
        》可以对内置数据类型以及自定义数据类型的数据进行存储
        》将数组中的数据存储到堆区
        》构造函数中可以传入数组的容量
        》提供对应的拷贝构造函数以及operator=防止浅拷贝问题
        》提供尾插法和尾删法对数组中的数据进行增加和删除
        》可以通过下标的方式访问数组中的元素
        》可以获取数组中当前元素个数和数组的容量
       
        示例：
-------------
MyArray.hpp
-------------

//自己的通用数组类
       
#pragma once
#include <iostream>
using namespace std;

template<class T>
class MyArray
{
    public:
    //有参构造 参数 容量
    MyArray(int capacity)
    {        
        this->m_Capacity = capacity;
        this->m_Size = 0;
        this->pAddress = new T[this->m_Capacity];
    }

    //析构函数
    ~MyArray()
    {
        if (this->pAddress != NULL)
        {            
            delete[] this->pAddress;
            pAddress = NULL;
        }
    }

    //拷贝构造
    MyArray(const MyArray &arr)
    {      
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        
        //深拷贝
        this->pAddress = new T[m_Capacity];

        //将arr中的数据都拷贝过来
        for (int i=0; i<this->m_Size; i++)
        {
            this->pAddress[i] = arr.pAddress[i];
        }
    }

    //oprtator=防止浅拷贝问题
    MyArray &operator=(const MyArray &arr)
    {        
        //判断原来堆区是否有数据，如果有先释放
        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];
        for ( int i = 0; i < this->m_Size; i++ )
        {
            this->pAddress[i] = arr.pAddress[i];
        }
        return *this;
    }

    //尾插法
    void Push_Back(const T &val)
    {
        //判断容量是否等于大小
        if ( this->m_Capacity == this->m_Size )
        {
            cout << "容量已满" << endl;
            return;
        }
        this->pAddress[this->m_Size] = val; //在数组末尾插入数据
        this->m_Size++;  //更新数组大小
    }

    //尾删法
    void Pop_Back()
    {
        //让用户访问不到最后一个元素，即为尾删
        if ( this->m_Size == 0 )
        {
            cout << "数组为空" << endl;
            return;
        }
        this->m_Size--;
    }

    //通过下标方式访问数组中的元素 重载[]
    T &operator[](int index)
    {
        return this->pAddress[index];
    }

    //返回数组的容量
    int getCapacity()
    {
        return this->m_Capacity;
    }

    //返回数组的大小
    int getSize()
    {
        return this->m_Size;
    }
    private:
    T *pAddress;    //指针指向堆区开辟的真实数组
    int m_Capacity; //数组的容量
    int m_Size;     //数组的大小
};

-------------
MyArray.c
-------------

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

void PrintIntArray(MyArray <int> &arr)
{
    for (int i=0; i<arr.getSize(); i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test01()
{
    MyArray <int>arr1(5);

    for (int i=0; i<5; i++)
    {
        arr1.Push_Back(i);
    }

    cout << "arr1的打印输出为：" << endl;
    PrintIntArray(arr1);

    cout << "arr1的容量为：" << arr1.getCapacity() << endl;
    cout << "arr1的大小为：" << arr1.getSize() << endl;

    MyArray <int>arr2(arr1);
    cout << "arr1的打印输出为：" << endl;
    PrintIntArray(arr2);   

    arr2.Pop_Back();
    cout << "arr2尾删后的打印输出为：" << endl;
    PrintIntArray(arr2);
    cout << "arr1的容量为：" << arr2.getCapacity() << endl;
    cout << "arr1的大小为：" << arr2.getSize() << 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 test02()
{
    MyArray<Person>arr(10);
    Person p1("孙悟空", 999);
    Person p2("猪八戒", 900);
    Person p3("唐僧", 29);
    Person p4("红孩儿", 600);
    Person p5("哪吒", 888);
    Person p6("土行孙", 666);

    arr.Push_Back(p1);
    arr.Push_Back(p2);
    arr.Push_Back(p3);
    arr.Push_Back(p4);
    arr.Push_Back(p5);
    arr.Push_Back(p6);

    //打印数组
    PrintPersonArray(arr);

    //输出容量和大小   
    cout << "arr1的容量为：" << arr.getCapacity() << endl;
    cout << "arr1的大小为：" << arr.getSize() << endl;

}


int main(void)
{
    //test01();

    test02();
   
    system("pause");
    return 0;
}

 

chxchxkkk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构NO.00002】C++构建简单的队列：ADT抽象数据类型概念浅析 by arttnba3
arttnba3的博客
10-04 705
简单队列的构建：ADT抽象数据类型概念浅析绪论基本概念：数据结构：队列（Queue）基本概念：抽象数据类型（Abstract Data Type，ADT）什么是ADT？如何实现ADT？基本概念：接口（Connector）利用ADT接口实现队列数据类型一、建立抽象二、建立接口三、实现队列功能1、初始化一个非空队列2、确定队列当中的项数3、在队尾使一个新项入队4、在队头使一个项出队5、检查队列是否为空...
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
c++概念搞定未知类型
个人进步之路
09-16 367
c++概念搞定未知类型
条款16:成对使用new和delete时要采取相同形式
scofieldzhu的专栏
06-12 771
条款16:成对使用new和delete时要采取相同形式        (Use the same form in corresponding uses of new and delete.)内容:    我们来看下面这段简单的代码:    class Phone{...};    //test.cpp    Phone* pPhoneArray=new Phone[4];    assert(
C++学习——函数模板、类模板
infinite66的博客
03-03 156
C++泛型编程：用模板技术实现【参数类型化】 函数模板的基本使用方法 template<class T> 或 template<typename T>告诉编译器紧跟的代码里出现T不要报错 例子：交换两个数字【如果按照常规的写法，那一种数据类型就要写一个函数，太麻烦】 void mySwapInt(int &a, int &b) { int tmp = a; a = b; b = tmp; } void mySwapDouble(double &...
自定义数组
qq_64360901的博客
02-24 390
希望有用吧
C++学习笔记
最新发布
ftm_csdn的博客
04-16 4506
C++是C语言的超集。
c++学习笔记
weixin_54948102的博客
02-06 297
自用笔记。
C++学习笔记（超详细笔记记录ing）
weixin_56868328的博客
02-14 842
C++学习笔记（1）C++基础语法：编写程序，注释，变量，常量，数据类型...
C++学习笔记.pdf
08-12
C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C++学习笔记 C++学习笔记
08-06
C++学习笔记
杂记：网络游戏中用到的一些网络协议
chxchxkkk的博客
07-26 4463
【协议】 数据包可以想象成是在网络上传输的电子信封。在它的数据头中有地址和其他相关信息，然后才发出真正的数据帧。 网络数据传输，有着很多不同的协议或规则来定义数据包以什么格式以及为了发送必须 做些什么。 网络游戏现在通常会让游戏逻辑使用两种协议之一：TCP、UDP。有的游戏会使用第三种协议，ICMP，常用于一些非游戏逻辑的功能。 【IP】 全称是Internet Protocol（网际网络协议），要通过网络发送数据，这是需要遵守的最基本的协议。不管是ICMP、TCP还是UDP，都必须附加I...
C语言基础知识：顺序结构
chxchxkkk的博客
12-22 2342
顺序结构 1、定义：从main()开始，由上往下一条一条地执行语句 2、三大类语句：注释、定义、执行语句。 【执行语句】：五类 控制语句（9条） 函数调用语句； 表达式语句； 空语句；-> 只有一个分号的语句。 复合语句{ }-> 花括号只算一条语句。 3、顺序结构的程序设计框架 #include <> main() { 输入 计算 输出 ...
Winsock编程二：简单的聊天程序
chxchxkkk的博客
08-07 1811
客户端： #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #include <winsock.h> #include <windows.h> #pragma comment(lib, "wsock32.lib") int main(void) { char Sendbuf[100]; //发送数据
单链表：学生成绩管理系统
chxchxkkk的博客
03-24 1516
单链表：学生成绩管理系统 student.h #pragma once #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #include <windows.h> struct STUDENT { char ID[8]; char name[20]; char sex[4.
Winsock编程一：基本概念和简单实例
chxchxkkk的博客
08-07 839
什么是Winsock Winsock是Windows下的网络编程接口，它是由Unix下的BSD Socket发展而来,是一个与网络协议无关的编程接口。 构建编程环境 Winsock在常见的Windows平台上有两个主要的版本，即Winsock1和Winsock2。编写与Winsock1兼容的程序你需要引用头文件WINSOCK.H，如果编写使用Winsock2的程序，则需要引用WINSOCK2.H。此外还有一个MSWSOCK.H头文件，它是专门用来支持在Windows平台上高性能网络程序...
内存中的数据
chxchxkkk的博客
03-24 834
【内存中的数据】 只有指针才能访问 【堆】中的数据。 数据在内存中的存放分为六个区域 ●程序代码区：存放程序编译后的可执行代码 ●全局区（静态区）：全局变量和静态变量的存储是放在一起的，初始化的全局变量和初始化的静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。 ●常量区：常量就是放在这里的，程序结束后由系统释放。 ●堆区：一般用来存放比较大的程序，一般由...
零基础c++学习笔记pdf
05-16
《零基础C语言学习笔记》pdf是一份非常好的学习材料。该pdf对C语言进行了系统的介绍，并且从最基础的内容开始进行讲解，适合于零基础的初学者学习。尤其是对于那些没有编程经验的人，该pdf提供了很多实用的示例和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值