• 2023/9/14 -- C++/QT

    作业：

    仿照Vector实现MyVector，最主要实现二倍扩容

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. template <typename T>
    6. class MyVector
    7. {
    8. private:
    9.     T *data;
    10.     size_t size;
    11.     size_t V_capacity;
    12. public:
    13.     //无参构造
    14.     MyVector():data(nullptr),size(0),V_capacity(0) {
    15.         //cout<<"MyVector::无参构造"<
    16.     }
    17.     //有参构造
    18.     MyVector(int count,T val){
    19.         size = count;
    20.         V_capacity = count;
    21.         data = new T[count];
    22.         for(int i = 0;i < count;i++){
    23.             data[i] = val;
    24.         }
    25.         //cout<<"MyVector::有参构造"<
    26.     }
    27.     //析构函数
    28.     ~MyVector(){
    29.         delete [] data;
    30.         data = nullptr;
    31.         //cout<<"MyVector::析构函数"<
    32.     }
    33.     // 定义迭代器类
    34.     class MyIterator {
    35.     private:
    36.         T* ptr;
    37.     public:
    38.         //有参构造
    39.         MyIterator(T* p):ptr(p){
    40.             //cout<<"MyIterator::有参构造"<
    41.         }
    42.         // *重载
    43.         T& operator*()const {
    44.             return *ptr;
    45.         }
    46.         // 前置++重载
    47.         MyIterator& operator++() {
    48.             ++ptr;
    49.             return *this;
    50.         }
    51.         // 后置++重载
    52.         MyIterator operator++(int) {
    53.             MyIterator temp = *this;
    54.             ++ptr;
    55.             return temp;
    56.         }
    57.         // 前置--重载
    58.         MyIterator& operator--() {
    59.             --ptr;
    60.             return *this;
    61.         }
    62.         // 后置--重载
    63.         MyIterator operator--(int) {
    64.             MyIterator temp = *this;
    65.             --ptr;
    66.             return temp;
    67.         }
    68.         // ==重载
    69.         bool operator==(const MyIterator& other) const {
    70.             return ptr == other.ptr;
    71.         }
    72.         // !=重载
    73.         bool operator!=(const MyIterator& other) const {
    74.             return ptr != other.ptr;
    75.         }
    76.     };
    77.     //begin 函数  返回第一个元素的迭代器
    78.     MyIterator begin() {
    79.         return MyIterator(data);
    80.     }
    81.     //end 函数  返回最末元素的迭代器(注:实指向最末元素的下一个位置)
    82.     MyIterator end() {
    83.         return MyIterator(data + size);
    84.     }
    85.     //assign 函数  对MyVector中的元素赋值
    86.     void assign(size_t num, const T &val ){
    87.         for(int i = 0;i < num;i++){
    88.             data[i] = val;
    89.         }
    90.         cout<<"assign 函数"<
    91.     }
    92.     //at 函数  返回指定位置的元素
    93.     T at(int pos){
    94.         if(pos < 0 || pos >= size){
    95.             throw int(1);                 //抛出异常
    96.         }
    97.         return data[pos];
    98.     }
    99.     //back 函数 返回最末一个元素
    100.     T& back(){
    101.         return data[size-1];
    102.     }
    103.     //capacity 函数  返回vector所能容纳的元素数量
    104.     size_t capacity(){
    105.         return V_capacity;
    106.     }
    107.     //clear 函数  清空所有元素
    108.     void clear(){
    109.         size = 0;
    110.     }
    111.     //empty 函数  判空
    112.     bool empty(){
    113.         return size == 0;
    114.     }
    115.     //front 函数  返回第一个元素
    116.     T& front(){
    117.         return data[0];
    118.     }
    119.     //pop_back 函数  移除最后一个元素
    120.     void pop_back(){
    121.         if(empty()){
    122.             throw int(2);           //抛出异常
    123.         }
    124.         size--;
    125.     }
    126.     //push_back 函数  在MyVector最后添加一个元素
    127.     void push_back(const T& value) {
    128.         if (size == V_capacity) {
    129.             // 扩容逻辑
    130.             size_t newCapacity = (V_capacity == 0)?1:V_capacity * 2;
    131.             T* newData = new T[newCapacity];
    132.             for(int i = 0;i < static_cast<int>(size);i++){
    133.                 newData[i] = data[i];
    134.             }
    135.             delete[] data;
    136.             data = newData;
    137.             V_capacity = newCapacity;
    138.         }
    139.         data[size++] = value;
    140.     }
    141.     //size 函数  返回Vector元素数量的大小
    142.     size_t get_size(){
    143.         return size;
    144.     }
    145. };
    146.  
    147. int main()
    148. {
    149.     MyVector<int> V1(5,2);
    150.     cout<<"V1的第一个元素 = "<front()<
    151.     cout<<"V1的最末一个元素 = "<back()<
    152.     cout<<"V1的capacity = "<capacity()<
    153.     cout<
    154.     cout<<"********************************************************"<
    155.     cout<
    156.  
    157.     V1.push_back(8);
    158.     V1.push_back(5);
    159.     V1.push_back(7);
    160.     V1.push_back(6);
    161.     cout<<"V1的第一个元素 = "<front()<
    162.     cout<<"V1的最末一个元素 = "<back()<
    163.     cout<<"V1的capacity = "<capacity()<
    164.     cout<<"V1的size = "<get_size()<
    165.     cout<
    166.     cout<<"********************************************************"<
    167.     cout<
    168.  
    169.     int *p = NULL;
    170.     MyVector<int>::MyIterator q(p);
    171.     cout<<"当前容器内的元素:";
    172.     for(q = V1.begin();q != V1.end();q++){
    173.         cout<< *q <<"\t";
    174.     }
    175.     cout<
    176.     cout<
    177.     cout<<"********************************************************"<
    178.     cout<
    179.  
    180.     V1.pop_back();
    181.     cout<<"V1的最末一个元素 = "<back()<
    182.     V1.pop_back();
    183.     cout<<"V1的最末一个元素 = "<back()<
    184.     V1.pop_back();
    185.     cout<<"V1的最末一个元素 = "<back()<
    186.     cout<<"V1的size = "<get_size()<
    187.     cout<
    188.     cout<<"********************************************************"<
    189.     cout<
    190.  
    191.     V1.clear();
    192.     cout<<"V1的size = "<get_size()<
    193.  
    194.     return 0;
    195. }

    效果图：

    一、异常处理

    【1】异常概念

    C++中的异常指的是在程序运行过程中出现的问题，没有任何语法错误，存在逻辑问题

    【2】异常处理

    1. throw ----->抛出异常，抛出异常一定在异常发生之前
    2. try ····catch ----->捕获异常并进行异常处理

    总结：

    1. 抛出异常一定在发生异常之前
    2. try···catch中可以存放所有可能发生异常的代码，只要有一条语句抛出异常，try后面的语句都不会执行
    3. 异常可以只有数据类型，也可以及有数据类型也有值
    4. catch可以通过数据类型，获取到异常的结果并使用if进行判断，如果每种异常抛出的都是不同的数据类型，catch中就无需定义变量
    5. 如果同种数据类型的异常有多个值，要依次根据值来判断异常的情况
    6. throw抛出异常往往被调函数的位置，try···catch往往在主调函数内处理异常
    1. #include 
    2. using namespace std;
    3.  
    4. void fun(int a,int b)
    5. {
    6.     //throw 数据类型(值)
    7.     //数据类型:指定抛出异常的类型，便于接收
    8.     //值：针对不同的异常情况，给出不同的值，处理异常时使用
    9.  
    10.     //在执行语句之前先对可能发生异常的位置进行判断
    11.     if(b==0)
    12.     {
    13.         throw double(1);
    14.     }
    15.     if(b==3)
    16.     {
    17.         //函数内抛出了两个double类型的异常，分别返回不同的值
    18.         throw int(2);
    19.     }
    20.     if(b==2)
    21.     {
    22.         throw double(2);
    23.     }
    24.  
    25.     cout << a/b << endl;
    26. }
    27.  
    28.  
    29. //处理异常一般在主函数内
    30. //try···catch处理异常
    31. int main()
    32. {
    33.     //tyr尝试接收异常，try内可以放多条语句，
    34.     //有一条语句抛出异常后，后面都不会执行
    35.     try
    36.     {
    37.         //try去接收所有可能的异常
    38.         fun(4,2);
    39.         fun(2,1);
    40.         fun(3,3);
    41.  
    42.     }
    43.     //由于函数中，只有一个double类型的异常，所以可以直接对异常的类型进行判断
    44.     catch (double a)    //如果double后面加变量名，变量会获取到异常的结果
    45.     {
    46.         if(a==1)
    47.             cout << "除数为0" << endl;
    48.         if(a==2)
    49.             cout << "除数为2是一个测试" << endl;
    50.     }
    51.     catch (int)
    52.     {
    53.         cout << "除数为3是一个测试" << endl;
    54.     }
    55.     fun(3,1);
    56.  
    57.  
    58.     cout << "1" << endl;
    59. }
    60.

    二、using的第三种用法

    1. #include 
    2.  
    3. //using namespace std;
    4. using std::string;
    5. class A
    6. {
    7. public:
    8.     string name;
    9. };
    10. class B:public A
    11. {
    12. protected:
    13.     using A::name;
    14. };
    15. namespace P {
    16.     string n1;
    17. }
    18.  
    19. //给命名空间重命名
    20. //namespace 新的名字 = 旧的名字
    21. //新名字和旧名字都能用
    22. namespace O = P;
    23. int main()
    24. {
    25.     using std::cout;
    26.     using std::endl;
    27.  
    28.     typedef int a;    //后面可以直接使用a定义int类型的变量
    29.     //C++11支持的
    30.     using  INT  = int;   //后面可以直接使用INT定义int类型的变量
    31.     INT num1 = 100;
    32.     cout << num1 << endl;
    33.     P::n1 = "helo";
    34.     O::n1 = "hi";
    35.     cout << O::n1 << endl;
    36.  
    37.     return 0;
    38. }

    三、类型转换

    【1】隐式强转

    以及和C中一致的显式强转

    1. #include 
    2. using namespace std;
    3.  
    4. int main()
    5. {
    6.     float num1 = 2.3;
    7.     int num2 = num1;    //发生了隐式的强制类型转换
    8.     
    9.     //C中的显式强制类型转换
    10.     double num3 = (double)num2;
    11.     cout << num2 << endl;
    12.     return 0;
    13. }

    【2】C++中支持的强制类型转换

    1. const_cast，取消常属性，取消常量指针的属性
    2. static_cast，和平时使用时发生强转用法一致，几乎支持所有类型间的强转
    3. dynamic_cast，发生在父子类指针间的转换，如果转换失败，会返回空地址
    4. reinterpret_cast，给类型重新赋值，不常用，不会检查数据类型匹配问题
    1. #include 
    2. using namespace std;
    3.  
    4. class A
    5. {
    6.     string name;
    7. public:
    8.     virtual void show()
    9.     {
    10.         cout << name << endl;
    11.     }
    12. };
    13.  
    14. class B:public A
    15. {
    16.     mutable int age;
    17. public:
    18.     void fun()const
    19.     {
    20.          age = 90;
    21.     }
    22.     void show()
    23.     {
    24.         cout << &age << endl;
    25.     }    
    26. };
    27.  
    28. int main()
    29. {
    30.     //定义了一个常量num1
    31.     const int num1 = 90;
    32.     int *p;   //定义了一个指针变量
    33.     p = const_cast<int *>(&num1);   //使用const_cast让指针指向const修饰的变量的地址
    34.     *p = 12;
    35.     cout << *p << endl;
    36.     //mutable关键也可以取消常属性
    37.  
    38.     //static_cast适用于几乎所有的强制类型转换
    39.     char var = 'a';
    40.     int num2;
    41.     //int num2 = (int)var;
    42.     num2 = static_cast<int>(var);
    43.     cout << num2 << endl;
    44.     
    45.     A* p1 = new B;    //父类指针指向子类的空间
    46.     A* p2 = new A;    //父类指针指向父类的空间
    47.     //B* p3 = static_cast(p2);  p2指向父类的空间，但是static_cast可以强转成功
    48.     B* p3 = dynamic_cast(p2);
    49.     //使用了dynamic_cast,可以实现多态情况下，可以实现父子类指针的转换
    50.     //如果父类指针没有指向子类的空间，返回值为0
    51.     cout << "父类指针指向父类的空间" << p2 << endl;
    52.     cout << "子类的指针" << p3 << endl;
    53.     B* p4 = reinterpret_cast(p2);
    54.     cout << "父类指针指向父类的空间" << p2 << endl;
    55.     cout << "子类的指针" << p4 << endl;
    56.     
    57.     char *str = "hello";
    58.     int a = reinterpret_cast<int>(str);
    59.     cout << a << endl;
    60.     //p3->show();
    61.  
    62.     return 0;
    63. }

    四、lambda表达式

    应用场合：

    想要使用匿名的、临时的函数，并且还需要获取外部变量时

    1. lambda(λ)表达式，是C++11支持的
    2. lambda表达式，用于实现轻量级的匿名函数
    3. 定义：[]()mutable->返回值{函数体}; --->结果一般使用auto接收
    1. [捕获列表](参数列表)mutable->返回值{函数体};
    2. 1、[=]：对所有变量按值捕获
    3.    [&]:对所有变量按引用捕获
    4.    [a,b]:对a和b按值捕获
    5.    [&a,&b]:对a和b按引用捕获
    6.     //[=,&a]:对除a外的变量值捕获，a按引用捕获
    7.     //[&,a]:对除a外的变量按引用捕获，a按值捕获
    8.  
    9. 2、参数列表:和普通函数的参数一致，就是传参数到函数中
    10. 3、mutable可以写也可以不写：
    11. 如果不写mutable，在lambda表达式中不能修改按值捕获的变量的值，按引用捕获的不受影响
    12. 4、lambda实现的匿名函数的返回值
    13. 5、函数体就是匿名函数的实现
    1. #include 
    2. using namespace std;
    3.  
    4. int main()
    5. {
    6.     int a = 90,b = 7,c,d,e;
    7.     cout << "a=" << a << endl;
    8.     cout << "b=" << b << endl;
    9.     cout << "--------------------" << endl;
    10.     //使用lambda表达式，实现主函数内变量值的交换
    11.     //[=]：对所有变量按值捕获
    12.     //[&]:对所有变量按引用捕获
    13.     //[a,b]:对a和b按值捕获
    14.     //[&a,&b]:对a和b按引用捕获
    15.     //[=,&a]:对除a外的变量值捕获，a按引用捕获
    16.     //[&,a]:对除a外的变量按引用捕获，a按值捕获
    17.  
    18.     //lambda表示式，使用auto类型获取
    19.     auto fun = [&,a]()mutable->void{ int temp;
    20.                                       temp = a;
    21.                                       a = b;
    22.                                       b = temp;};
    23.     fun();
    24.     //使用lambda实现求最大值
    25.     auto max = [=]()->int{  if(a>b)
    26.                              return a;
    27.                             else
    28.                               return b; };
    29.     cout << max() << endl;
    30.     return 0;
    31. }

    五、STL标准模板库

    C++ Standard Template Library

    C++ 标准模板库(STL)

    C++ STL (Standard Template Library标准模板库) 是通用类模板和算法的集合，它提供给程序员一些标准的数据结构的实现如 queues(队列), lists(链表), 和 stacks(栈)等.

    C++ STL 提供给程序员以下三类数据结构的实现:

    • 顺序结构
      • C++ Vectors
      • C++ Lists
      • C++ Double-Ended Queues
    • 容器适配器
      • C++ Stacks
      • C++ Queues
      • C++ Priority Queues
    • 联合容器
      • C++ Bitsets
      • C++ Maps
      • C++ Multimaps
      • C++ Sets
      • C++ Multisets

    【1】Vector

    Vector的底层实现，就是线性表

    Vectors 包含着一系列连续存储的元素,其行为和数组类似。访问Vector中的任意元素或从末尾添加元素都可以在常量级时间复杂度内完成，而查找特定值的元素所处的位置或是在Vector中插入元素则是线性时间复杂度。

    需要手动导入头文件#include

    1. 1、求vetcor容器的大小：
    2. size_type capacity();
    3. capacity() 函数 返回当前vector在重新进行内存分配以前所能容纳的元素数量.
    4. 2、添加元素
    5. void push_back( const TYPE &val );
    6. push_back()添加值为val的元素到当前vector末尾
    7. 3、求容器的真实大小
    8. size_type size();
    9. size() 函数返回当前vector所容纳元素的数目 
    10. 4、给容器中的元素赋值
    11. void assign( size_type num, const TYPE &val );
    12. 赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值以前的内容.
    13. 5、访问容器中的元素
    14. TYPE at( size_type loc );
    15. at() 函数 返回当前Vector指定位置loc的元素的引用. at() 函数 比 [] 运算符更加安全, 因为它不会让你去访问到Vector内越界的元素.
    16. 6、清空容器中的元素
    17. void clear();
    18. clear()函数删除当前vector中的所有元素.
    19. 7、判空函数
    20. bool empty();
    21. 如果当前vector没有容纳任何元素,则empty()函数返回true,否则返回false.例如,以下代码清空一个vector,并按照逆序显示所有的元素:
    22. 8、返回起始位置的引用
    23. TYPE front();
    24. front()函数返回当前vector起始元素的引用
    25. 9、返回最后一个位置的引用
    26. TYPE back();
    27. back() 函数返回当前vector最末一个元素的引用.    
    28. 10、返回起始元素的迭代器
    29. iterator begin();
    30. begin()函数返回一个指向当前vector起始元素的迭代器.
    31. 11、返回末尾下一个位置的迭代器
    32. iterator end();
    33. end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.
    34. 注意,如果你要访问末尾元素,需要先将此迭代器自减1.
    35. 12、指定位置的插入，由于没有提供返回指定位置迭代器，需要在第一个元素的迭代器上运算
    36. iterator insert( iterator loc, const TYPE &val );
    37. 在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器, 
    38. 13、移除最后一个元素
    39. void pop_back();
    40. pop_back()函数删除当前vector最末的一个元素,
    41. 14、构造函数
    42. vector( input_iterator start, input_iterator end );
    43. 迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间).

    【2】List

    list的底层实现是一个双向链表

    主要功能

    1. 1、头插
    2. void push_front( const TYPE &val );
    3. push_front()函数将val连接到链表的头部。
    4. 2、最大容量
    5. size_type max_size();
    6. max_size()函数返回链表能够储存的元素数目
    7. 3、元素个数
    8. size_type size();
    9. size()函数返回list中元素的数量。
    10. 4、排序
    11. void sort();
    12. 给链表中的元素排序，默认是升序
    13. 5、判空
    14. bool empty();
    15. empty()函数返回真(true)如果链表为空，否则返回假。

  • 相关阅读:
    你了解PMP考试新考纲的内容吗？
    Django笔记三十四之分页操作
    微服务概述
    RNA-seq——四、根据序列比对结果筛选差异基因
    WebView输入框软键盘遮挡问题（沉浸状态栏和adjustResize的冲突）
    氧化锌纳米线 Zinc oxide nanowires
    电脑可以模拟人脑吗
    ai实景直播矩阵式引流---技术开发搭建（剪辑、矩阵、直播）
    HTML5和CSS3二接口
    【cesium】3D Tileset 模型加载并与模型树关联
  • 原文地址：https://blog.csdn.net/weixin_54147737/article/details/132890268