02_泛型编程与STL之黑马程序员day02

最新推荐文章于 2023-03-12 16:08:07 发布
最新推荐文章于 2023-03-12 16:08:07 发布
阅读量118 收藏
点赞数
分类专栏： STL与泛型编程学习笔记_侯捷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40817333/article/details/104515561
版权

1.MyArray

说明一：赋值构造函数一般与‘=’运算符重载函数同时出现。
说明二：关于左值和右值的介绍

#include<iostream>
using namespace std;

template<class T>
class MyArray{
public:
    MyArray<T>(int capacity){
        this->mCapacity = capacity;
        this->mSize = 0;
        //申请内存
        this->pAddr = new T[this->mCapacity];
    }
    MyArray<T>(const MyArray<T>& arr){
        this->mSize = arr.mSize;
        this->mCapacity = arr.mCapacity;
        
        //申请内存空间
        this->pAddr = new T[this->mCapacity];
        //数据拷贝
        for (int i = 0; i < this->mSize; i++){
            this->pAddr[i] = arr.pAddr[i];
        }
    }
    T& operator[](int index){
        return this->pAddr[index];
    }
    MyArray<T>& operator=(const MyArray<T>& arr){
        if (this->pAddr != NULL){
            delete[] this->pAddr;
        }
        this->mSize = arr.mSize;
        this->mCapacity = arr.mCapacity;
        //申请内存空间
        this->pAddr = new T[this->mCapacity];
        //数据拷贝
        for (int i = 0; i < this->mSize; i++){
            this->pAddr[i] = arr.pAddr[i];
        }
        return *this;
    }
    void PushBack(T& data){
        //判断容器中是否有位置
        if (this->mSize >= this->mCapacity){
            return;
        }
        //调用拷贝构造 =号操作符
        //1. 对象元素必须能够被拷贝
        //2. 容器都是值寓意，而非引用寓意 向容器中放入元素，都是放入的元素的拷贝份
        //3  如果元素的成员有指针，注意深拷贝和浅拷贝问题
        this->pAddr[this->mSize] = data;
        //msize++
        this->mSize++;
    }
    // T&& 对右值取引用
    void PushBack(T&& data){
        //判断容器中是否有位置
        if (this->mSize >= this->mCapacity){
            return;
        }
        //调用拷贝构造 =号操作符
        //1. 对象元素必须能够被拷贝
        //2. 容器都是值寓意，而非引用寓意 向容器中放入元素，都是放入的元素的拷贝份
        //3  如果元素的成员有指针，注意深拷贝和浅拷贝问题
        this->pAddr[this->mSize] = data;
        //msize++
        this->mSize++;
    }
    ~MyArray(){
        if (this->pAddr != NULL){
            delete[] this->pAddr;    
        }
    }
public:
    //一共可以容下多少个元素
    int mCapacity;
    //当前数组有多少元素
    int mSize;
    //保存数据的首地址
    T* pAddr;
};

void test01(){
    MyArray<int> marray(20);
    int a = 10, b = 20, c = 30, d = 40;
    marray.PushBack(a);
    marray.PushBack(b);
    marray.PushBack(c);
    marray.PushBack(d);
 
    //不能对右值取引用
    //左值 可以在多行使用
    //右值 临时变量 只能当前行使用
    marray.PushBack(100);
    marray.PushBack(200);
    marray.PushBack(300);

    for (int i = 0; i < marray.mSize; i++){
        cout << marray[i] << " ";
    }
    cout << endl;
}

class Person{};

void test02(){
    Person p1, p2;
    
    MyArray<Person> arr(10);
    arr.PushBack(p1);
    arr.PushBack(p2);
}
int main(){
    test01();
    
    return 0;
}

2.类型转换

a) static_cast
1.可转换基础数据类型(int、char、double等)

char c = static_cast<char>(97);

2.不可转换基础数据类型指针

//下面代码错误
int* p = NULL;
char* sp = static_cast<char*>(p);

3.不可转换对象指针

class Building{};
class Animal{};
class Cat : public Animal{};

//下面代码错误
Building* building = NULL;
Animal* ani = static_cast<Animal*>(building);

4.可转换具有继承关系的对象指针

class Animal{};
class Cat : public Animal{};

//父类指针转成子类指针
 Animal* ani = NULL;
 Cat* cat = static_cast<Cat*>(ani);
 //子类指针转成父类指针
 Cat* soncat = NULL;
 Animal* anifather = static_cast<Animal*>(soncat);

5.不可将父类对象引用转换为子类对象引用(子类的信息一般比父类多)，但可以将子类对象引用转换为父类对象引用。

class Animal{};
class Cat : public Animal{};

//下面代码错误
Animal aniobj;
Animal& aniref = aniobj;
Cat& cat = static_cast<Cat&>(aniref);

//下面代码正确
Cat catobj;
Cat& catref = catobj;
Animal& anifather2 = static_cast<Animal&>(catref);

b) dynamic_cast
1.不可转换基础数据类型

//下面代码错误
int a = 10;
char c = dynamic_cast<char>(a);

2.不可转换没有继承关系的指针

class Building{};
class Animal{};

//下面代码错误
Animal* ani = NULL;
Building* building = dynamic_cast<Building*>(ani);

3.不可将父类对象指针转换为子类对象指针(dynamic_cast会进行类型安全检查)

class Animal{};
class Cat : public Animal{};

//下面代码错误
Animal* ani = NULL;
Cat* cat = dynamic_cast<Cat*>(ani);

4.可以将子类对象指针转换为父类对象指针

class Animal{};
class Cat : public Animal{};

Cat* cat = NULL;
Animal* ani = dynamic_cast<Animal*>(cat);

c)const_cast
1.可以转换基础数据(注意第四行的注释)

int a = 10;
const int& b = a;
//b = 10;
int& c = const_cast<int&>(b);  // b本身的const性并没有更改
c = 20;

2.可以转换指针的const属性

const int* p = NULL;
int* p2 = const_cast<int*>(p);

int* p3 = NULL;
const int* p4 = const_cast<const int*>(p3);

d) reinterpret_cast
1.不可转换基础数据类型，代码略
2.无关的指针类型都可转换

class Building{};
class Animal{};

Building* building = NULL;
Animal* ani = reinterpret_cast<Animal*>(building);

3.可转换函数指针类型

typedef void(*FUNC1)(int, int);
typedef int(*FUNC2)(int, char*);

FUNC1 func1;
FUNC2 func2 = reinterpret_cast<FUNC2>(func1);

总结：
static_cast 用于内置的数据类型，还有具有继承关系的指针或者引用；
dynamic_cast 只能转换具有继承关系的指针或者引用，并且只能由子类型转成基类型；
const_cast 用于增加或者去除变量的const性；
reinterpret_cast 可以强制类型转换相互无关的指针类型，包括函数指针都可以进行转换。

3.异常机制

说明一：如果函数B中嵌套函数A，如果抛出异常，则异常是由A抛出(假设A可以抛出异常)，举例说明。

#include<iostream>
using namespace std;

int divide(int x ,int y){
    if (y == 0)
        throw -1;  //抛异常

    return x / y;
}
void test01(){
    //试着去捕获异常
    try{
        divide(10, 0);
    }
    catch (int e){ //异常时根据类型进行匹配
        cout << "除数为" << e << "!" << endl;
    }
}
void CallDivide(int x,int y){
    divide(x, y);
}
void test02(){
    try{
        CallDivide(10,0);
    }
    catch (int e){
        cout << "除数为" << e << endl;
    }
}
int main(){
    //test01();
    test02();
}

在test02()中，CallDivide()会调用divide()。而在divide()函数中，如果除数为0则会抛出异常，这个异常会被test02()中的catch()捕获。这个例子说明调用函数时，会一直追踪至“终点”函数且异常由终点函数抛出。

4.栈解旋

栈的解旋：异常被抛出后，从进入try块起，到异常被抛掷前，这期间在栈上的构造的所有对象，都会被自动析构，析构的顺序与构造的顺序相反。

#include <iostream>
using namespace std;

class Person{
public:
    Person(){
        cout << "对象构建!" << endl;
    }
    ~Person(){
        cout << "对象析构!" << endl;
    }
};

int divide(int x,int y){
    Person p1, p2;
    
    if (y == 0)
        throw y;
        
    return  x / y;
}
int main(){
    try{
        divide(10,0);
    }
    catch (int e){
        cout << "异常捕获！" << endl;
    }
    
    return 0;
}

上述代码的输出为：

对象构建!
对象构建!
对象析构!
对象析构!
异常捕获！

5.异常接口声明

具体语法见下方代码：

#include <iostream>
using namespace std;

//这个函数只能抛出int float char三种类型异常，抛出其他的就报错
void func() throw(int,float,char){
    throw "abc";
}

//不能抛出任何异常
void func02() throw(){
    throw -1;
}

//可以抛出任何类型异常
void func03(){}

int main(void) {
    try{
        func();
    }
    catch (char* str){
        cout << str << endl;
    }
    catch (int e){
        cout << "异常!" << endl;
    }
    catch (...){ //捕获所有异常
        cout << "未知类型异常！" << endl;
    }
    
    return 0;
}

输出：

abc

6.异常类型

具体用法见下面代码：

#include <iostream>
using namespace std;

void func01(){
    throw 1; //抛出int类型异常
}

void func02(){
    throw "exception"; //抛出string类型异常
}

class MyException{
public:
    MyException(char* str){
        error = new char[strlen(str)+1];
        strcpy(error, str);
    }
    MyException(const MyException& ex){   // MyException("我刚写异常！") 赋值给 MyException e
        this->error = new char[strlen(ex.error) + 1];
        strcpy(this->error,ex.error);
    }
    MyException& operator=(const MyException& ex){  // 同上
        if (this->error != NULL){
            delete[] this->error;
            this->error = NULL;
        }
        this->error = new char[strlen(ex.error) + 1];
        strcpy(this->error, ex.error);
    }
    void what(){
        cout << error << endl;
    }
    ~MyException(){
        if (error != NULL){
            delete[] error;
        }
    }
public:
    char* error;
};

void fun03(){
    throw MyException("我刚写异常！");
}

void test01(){
    try{
        func01();
    }
    catch (int e){
        cout << "异常捕获！" << endl;
    }
//..................//
    try{
        func02();
    }
    catch (char* e){
        cout << "异常捕获！" << endl;
    }
//..................//  
    try{
        fun03();
    }
    catch (MyException e){
        e.what();
    }
}

int main(void){
    test01();
    return 0;
}

输出：

异常捕获！
异常捕获！
我刚写异常！

7.异常对象生命周期

#include <iostream>
using namespace std;

class MyException{
public:
    MyException(){
        cout << "构造函数!" << endl;
    }

    MyException(const MyException& ex){
        cout << "拷贝构造!" << endl;
    }
    
    ~MyException(){
        cout << "析构函数！" << endl;
    }
};

void func(){
    //创建匿名对象 调用构造
    //throw new(MyException()); 
    throw MyException();
}

void test01(){
    //普通类型元素  引用  指针  
    //普通元素 异常对象在catch处理完之后就析构
    //引用的话 不用调用拷贝构造，异常对象catch处理完之后就析构
    //若是指针，异常对象在catch处理之前就析构
    try{
        func();
    }
    catch (MyException& e /* MyException* e */){
        cout << "异常捕获!" << endl;
        /*delete e;*/
    }
}

int main(void){
    test01();
    return 0;
}

说明一：若在test01()中将MyException& e改为MyException e，则当catch()捕获异常时会将e复制构造，然后打印“异常捕获！”，最后两个MyException对象会被析构。
结果如下：

构造函数！
拷贝构造！
异常捕获！
析构函数！
析构函数！

说明二：若test01()中，不更改MyException& e，则在catch()执行完之后，MyException对象会被析构。
结果如下：

构造函数！
异常捕获！
析构函数！

说明三：在test01()中，更改MyException& e为MyException* e，同时将func()中的 throw MyException();该为 throw &(MyException());。则在执行catch()语句之前，MyException对象就会被析构。
结果如下：

构造函数！
析构函数！
异常捕获！

8.Cpp标准异常库举例

注意test02()中的两句注释！！！

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

class Person{
public:
    Person(){
        mAge = 0;
    }
    void setAge(int age){
        if (age < 0 || age > 100){
            throw out_of_range("年龄应该在0-100之间!");
        }
        this->mAge = age;
    }
public:
    int mAge;
};

void test01(){
    Person p;
    try{
        p.setAge(1000);
    }
    catch (exception e){  // out_of_range的父类是exception
        cout << e.what() << endl;
    }
}

class MyOutOfRange : public exception{
public:
    MyOutOfRange(char* error){
        pError = new char[strlen(error) + 1];
        strcpy(pError, error);
    }
    ~MyOutOfRange(){
        if (pError != NULL){
            delete[] pError;
        }
    }
    virtual const char * what() const{
        return pError;
    }
public:
    char* pError;
};

void fun02(){
    throw MyOutOfRange("我自己的out_of_range!");
}

void test02(){ 
    try{
        fun02();
    }
    catch (exception& e){   
        // 使用引用捕获异常，可以通过基类对象实现虚函数的虚调用，在运行时提现多态性
        // 如果使用值传递捕获异常， 则会显示基类what()函数的调用
        cout << e.what() << endl;
    }
}

int main(void){
    //test01();
    test02();
    return 0;
}

9.继承在异常中的应用

在这里插入图片描述
而exception 类位于 头文件中，它被声明为：

class exception{
public:    
    exception () throw();  //构造函数    
    exception (const exception&) throw();  //拷贝构造函数   
    exception& operator= (const exception&) throw();  //运算符重载    
    virtual ~exception() throw();  //虚析构函数    
    virtual const char* what() const throw();  //虚函数
}

具体用法参考下面代码：

#include <iostream>
using namespace std;

//异常基类
class BaseMyException{
public:
    virtual void  what() = 0;
    virtual ~BaseMyException(){}
};

class TargetSpaceNullException : public BaseMyException{
public:
    virtual void  what(){
        cout << "目标空间空!" << endl;
    }
    ~TargetSpaceNullException(){}
};

class SourceSpaceNullException : public BaseMyException{
public:
    virtual void  what(){
        cout << "源空间为空!" << endl;
    }
    ~SourceSpaceNullException(){}
};

void copy_str(char* taget,char* source){
    if (taget == NULL){
        throw TargetSpaceNullException();
    }
    if (source == NULL){
        throw SourceSpaceNullException();
    }
    //int len = strlen(source) + 1;
    while (*source != '\0'){
        *taget = *source;
        taget++;
        source++;
    }
}
int main(void){
    char* source = "abcdefg";
    char buf[1024] = {0};
    try{
        copy_str(buf, NULL);
    }
    catch (BaseMyException& ex){
        ex.what();
    }
}
百事_可乐
关注
专栏目录
泛型编程与STL中文版
08-04
高清《泛型编程与STL中文版》。。。。。。。。。。。。。。。。。。。。
《泛型编程与STL》（Matthew H. Austern[美] 著，侯捷 译）
01-19
《泛型编程与STL》阐述了泛型编程的中心思想：concepts、modeling、refinement,并为你展示这些思想如何导出STL的基础概念：iterators、containers、functionobjects.循此路线，你可以把STL想像为一个由concepts组成...
05_泛型编程与STL之黑马程序员day05
qq_40817333的博客
03-10 187
1.map容器 2.multimap容器 3.容器深拷贝和浅拷贝 4.函数对象 5.内建函数对象 6.函数对象适配器 7.常用的遍历算法
03_泛型编程与STL之黑马程序员day03
qq_40817333的博客
03-09 138
1.容器算法迭代器基本思路 2.STL_hello_world_程序 3.string容器 4.vector容器 5.Cpp输入输出流 6.文件读写
04_泛型编程与STL之黑马程序员day04
qq_40817333的博客
03-09 141
1.deque容器 2.stack容器 3.queue容器 4.list容器 5.set容器 6.对组
01_泛型编程与STL之黑马程序员day01
qq_40817333的博客
02-23 197
模板的基本介绍 模板技术使类型参数化，在编写代码时可以忽略类型，避免编写类似重复的代码。 为了让编译器区分普通函数和模板函数：在模板函数的函数声明前添加template< class T> 或者 template< typename T>。 模板函数可以通过传入函数的参数来自动推导类型，也可以显式地指定类型。 #include <iostream> using ...
哔哩哔哩黑马程序员C++课程个人学习笔记
weixin_53073284的博客
08-01 5473
此博文仅作为个人c++学习笔记记录，或有错误不建议参考！！！
Visual Studio 2022版本 B站黑马程序员C++自学分享－第一阶段（主要包括：自己敲的代码、通过注释来备注上自己对代码的理解）
codeLearnerEternally的博客
03-12 3209
黑马的课程里面分为了三大阶段 一、第一阶段 C++基础语法入门 对C++有初步了解，能够有基础编程能力 二、第二阶段 C++核心编程 介绍C++面向对象编程，为大型项目做铺垫 三、第三阶段 C++提高编程 介绍C++泛型编程思想，以及STL的基本使用 ※※※我会一个阶段发一个文章，一共发布三个文章来把学习的代码还有自己在代码旁边标注的对于这些代码的理解和心得体会一起分享给大家！！！
C++入门、STL学习、二级C++等
青少年趣味编程
09-04 514
C++入门、STL学习、二级C++等
C++学习笔记day4（模板和stl）
qq_61100395的博客
04-02 598
函数模板： c++另一种编程思想称为泛型编程，主要利用的技术就是模板。 c++提供两种模板机制：函数模板和类模板。 函数模板作用： 建立一个通用函数，函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。 语法： template<typename T> 函数声明或定义 解释： template--声明创建模板 typename--表明其后面的符号是一种数据类型，可以用class代替。 T--通用的数据类型，名称可以替换，通常为大写字母。 两种方式使用函数模板： 1.自动类型推导 my
黑马程序员---java之高新技术基础加强篇
ganjiaman的专栏
07-01 736
java高新技术篇  ------- android培训、java培训、期待与您交流！ ----------   1.静态导入与编译器语法设置 import语句可以导入一个类或某个包中的所有类；import static语句导入一个类中的某个静态方法或所有静态方法。 语法举例： 使用求2个数的最大值和相减结果的绝对值进行举例 System.out.println(min(3,5)
Cpp设计新思维_泛型编程与设计模式之应用
02-16
《Cpp设计新思维_泛型编程与设计模式之应用》这本书深入探讨了C++编程中的泛型编程和设计模式的应用，对于提升C++开发者的技术水平具有极高的价值。以下是本书涉及的一些关键知识点： 1. 泛型编程：泛型编程是C++中...
泛型编程与STL.pdf
09-05
根据提供的文件信息，“泛型编程与STL.pdf”这一标题及描述主要聚焦于两个核心概念：泛型编程和标准模板库（Standard Template Library，简称STL）。这些是现代C++编程语言中的重要组成部分，对于软件开发人员来说...
电子商务之价格优化算法：动态定价：动态定价的实施与案例研究.docx
11-05
电子商务之价格优化算法：动态定价：动态定价的实施与案例研究.docx
VB程序实例-Office或IE风格的工具栏.zip
11-05
基于VB的程序实例，可供参考学习使用
aggdraw-1.3.14-cp39-cp39-win32.whl.rar
11-05
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
通用模板/素材/样式-100套大数据可视化系统大屏页面（开箱即用）+python源码+演示+文档说明
11-05
包含: 001 服务大数据可视化监管平台 002 水质情况实时监测预警系统 003 联心菜市场数据中心 004 政务大数据共享交换平台 005 可视化监控管理 006 全国疫情实时监控 007 惠民服务平台 009 某公司大数据监控平台 010 双数智慧公卫-传染病督导平台 011 大数据可视化系统数据分析通用模版 012 某公司大数据展示模版 013 某公司大数据展示模版 014 时实客流量监控中心 015 广西矿产资源大数据监管平台 016 某某科技有限公司-生产数据中心 017 大数据可视化通用素材 018 大数据可视化系统数据分析通用模版 等等 - 不懂运行，下载完可以私聊问，可远程教学 本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。
akima-2021.6.6-cp38-cp38-win32.whl.rar
11-05
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
使用java实现的简单飞机大战游戏.zip
最新发布
11-05
本资源提供了使用java实现的简单飞机大战游戏，是一款经典的2D射击游戏。玩家在游戏中控制一架飞机，通过键盘操作移动和发射子弹，击落敌机获得积分。当达到一定积分时，会出现Boss，增加游戏难度。游戏还包含碰撞检测、得分系统以及游戏状态管理等功能。该资源旨在帮助学习者掌握Java编程的各个方面，包括面向对象设计、图形界面编程等。通过这个项目，学习者可以深入理解如何使用Java语言实现一个具备基本功能的小游戏，并学会如何处理游戏中的交互、碰撞检测和动画效果等技术细节。本资源适合Java编程初学者及对游戏开发感兴趣的开发者学习和参考，是提升编程技能和项目经验的绝佳实践材料。
泛型编程与STL：C++模板深入解析
"大局觀：泛型程式設計与STL（Generic Programming） .pdf" 这篇文章讲述了泛型编程（Generic Programming）和标准模板库（STL）的重要性及其发展历程。泛型编程是一种编程范式，旨在创建独立于特定数据类型的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值