c++第十六天（异常处理与c++11新特性）

最新推荐文章于 2023-09-17 19:08:57 发布
最新推荐文章于 2023-09-17 19:08:57 发布
阅读量1.1k 收藏 6
点赞数 3
分类专栏： 笔记 python、c++ c++ 文章标签： 开发语言 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/open_python/article/details/127828213
版权
笔记 同时被 3 个专栏收录
29 篇文章 4 订阅
订阅专栏
c++
22 篇文章 2 订阅
订阅专栏
python、c++
6 篇文章 0 订阅
订阅专栏

目录

一、异常处理

异常处理的作用: 异常处理分离了接收和处理错误代码。为了替代error。

C++ 异常处理涉及到三个关键字：try、catch、throw。

1、throw: 当问题出现时，程序会抛出一个异常。通过使用 throw 关键字来完成。

格式：throw  错误代码。

2、try: try 块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 catch 块。

格式：try { 测试代码 } 

3、catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。

格式：catch（错误代码类型  变量）{ }

4、如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。

错误原因

二、c++11新特性

1、auto变量

2、枚举循环

3、final & override

4、随机数功能（比rand随机一点）

5、智能指针 unique_ptr 与 shared_ptr

区别：如果是定义一个普通指针指向堆空间，则需要手动释放该指针才能调用析构函数，因为该指针的生命周期是delete。如果是智能指针，则不需要手动释放该指针也可以调用析构函数。

shared_ptr 例子：（共享型）

补充：自定义删除器

6、类型转换

7、lambda表达式（QT上的槽会使用）

总结：

一、异常处理

异常处理的作用: 异常处理分离了接收和处理错误代码。为了替代error。

C++ 异常处理涉及到三个关键字：try、catch、throw。

1、throw: 当问题出现时，程序会抛出一个异常。通过使用 throw 关键字来完成。

格式：throw  错误代码。

2、try: try 块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 catch 块。

格式：try { 测试代码 } 

3、catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。

格式：catch（错误代码类型  变量）{ }

4、如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。

try   //测试代码 
{
   //发现异常   throw 抛出异常 
    
}catch( ExceptionName e1 )  //catch 捕抓异常
{
   // catch 块
}

demo

//设计一个字符串类，当用户访问下标越界时，抛出异常
#include<iostream>
using namespace std;
int main()
{
     try{
        string s = "hello";
   
        int i=0;
        while(1){
            if(s[i]=='\0'){
                throw 101; 
                break;  
            }
            i++;
        } 
    }
    catch(int e)
    {
        cout << "下标越界" << e << endl;
    }
    catch(...) //可以接收任何的数据类型
    {
        cout << "下标越界" << endl;
    }
}

可以在任意的地方抛出异常，当前抛出的异常未被处理时，程序会死亡。

标准错误格式
 try
 {
     测试代码
 }
catch(const std::exception& e)  //捕捉系统的所有异常。 
{
    std::cerr << e.what() << '\n';
}

错误原因

 

 demo2

#include <iostream>

using namespace std;

int main()
{
      
 //int  *p = new  int[1000000000000000000]; 
    try{ 
        //分配的空间过大，会抛出系统异常 
        int  *p = new  int[1000000000000000000]; 
    }catch(const std::exception& e){  //处理系统异常 
    
        //输出异常的原因
        std::cerr << e.what() << '\n';
    }
    cout << "程序继续运行" << endl;
}

二、c++11新特性

1、auto变量

作用：自动推导数据类型，方便使用。但在定义的时候要初始化。

auto   a = 10086;  
auto   b = "hello world";   
作用:自动推导变量的类型，一定要有数值才能推导。
auto c; //错误，没有数据值，无法推导

补充: decltype 分析变量的类型 
int i = 1;
decltype(i) b = 2; // b是int    decltype(i) 就是 int

2、枚举循环

例子：

#include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
    int a[3] = {1,2,3};
     枚举数组a中的各个元素，并赋值给 i  
    for(int i:a){
        cout << i << endl;
    }
    return 0;
}

demo 

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

int main()
{
    list<string> ls;
    ls.push_back("小明");
    ls.push_back("小红");
    ls.push_back("小芳");
    ls.push_back("小贝");

    //枚举格式：for(数据类型 对象 : 容器对象) { }
    ls.sort();    //排序函数
    for(string vet:ls){     //枚举
        cout << vet << endl;
    }

    cout << "--------翻转-----------\n";
    ls.reverse();    //翻转函数
    for(string vet:ls){
        cout << vet << endl;
    }
}

3、final & override

（1）final 用于修饰一个类，表示禁止该类进一步派生和虚函数的进一步重载，即禁止派生和虚函数重载。

final:类不能被继承
    
class Base final {
    virtual void func() {
        cout << "base" << endl;
    }
};

class Derived : public Base{ // 编译失败，final修饰的类不可以被继承
    void func() override {
        cout << "derived" << endl;
    }

};

（2）override 用于修饰派生类中的成员函数，标明该函数重写了基类函数，如果一个函数声明了override但父类却没有这个虚函数，编译报错，使用override关键字可以避免开发者在重写基类函数时无意产生的错误。即子类使用了父类没有的虚函数，则报错。

override 例子声明函数是重写函数

class Base {
    virtual void func() {
        cout << "base" << endl;
    }
};

class Derived : public Base{
    void func() override { // 确保func被重写
        cout << "derived" << endl;
    }
    void fu() override { // error，基类没有fu()，不可以被重写
        
    }
};

（3）explicit 禁止隐式转换 

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

class A {
    A(int value) { // 没有explicit关键字,可以隐式转换
        cout << "value" <<value    << endl;
    }
   explicit A(string value) { // explicit关键字,不能隐式转换 
        cout << "value"<< value << endl;
    }
};

int main() {

   A a = 1; // 可以隐式转换，调用 A(int value)  
   string  s="hello";
   A b = s;
   return 0;

}

4、随机数功能（比rand随机一点）

#include <time.h>
#include <iostream>
#include <random>
using namespace std;

int main() {
    //产生随机因子
    std::default_random_engine random(time(nullptr));
    //设置随机范围
    std::uniform_int_distribution<int> int_dis(0, 100); // 整数均匀分布
    std::uniform_real_distribution<float> real_dis(0.0, 1.0); // 浮点数均匀分布

    for (int i = 0; i < 10; ++i) {
        //输出随机数
        cout << int_dis(random) << ' ';
    }
    cout << endl;

    for (int i = 0; i < 10; ++i) {
        cout << real_dis(random) << ' ';
    }
    cout << endl;

    return 0;
}

5、智能指针 unique_ptr 与 shared_ptr

作用：自动释放所指向的堆空间

（1）unique_ptr 这是个独占式的指针对象，在任何时间、资源只能被一个指针占有，当

unique_ptr离开作用域，指针所包含的内容会被释放。（只能一个指针指向该空间）。

（2）shared_ptr使用了引用计数，每一个shared_ptr的拷贝都指向相同的内存，每次拷贝都会

触发引用计数+1，每次生命周期结束析构的时候引用计数-1，在最后一个shared_ptr析构的

时候，内存才会释放。（可以多个指针指向该空间）。

（3）语法: 
  unique_ptr<数据类型>  变量名(地址); 

  unique_ptr<数据类型>  变量名 = make_unique<类型>(参数);  

  shared_ptr<数据类型>  变量名(地址); 

  shared_ptr<数据类型>  变量名 = make_shared<类型>(参数); 

例子:定义一个智能指针 
unique_ptr<int> u_p(new int); 
unique_ptr<int> u_p1 = make_unique<int>(); 

shared_ptr<int> s_p(new int); 
shared_ptr<int>  s_p1 = make_unique<int>();

区别：如果是定义一个普通指针指向堆空间，则需要手动释放该指针才能调用析构函数，因为该指针的生命周期是delete。如果是智能指针，则不需要手动释放该指针也可以调用析构函数。

unique_ptr 例子：(独占型) 

//头文件
#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex> 
using namespace std;

class A {
public:
   A () {cout << "A init"  << endl;}
   ~A() {
       cout << "A delete" << endl;
   }
};
//测试 
void  test(){
   cout << "test" << endl;
    //使用普通指针
   A *p =  new A;
}

void test1()
{
    cout << "test1" << endl;
    //使用智能指针
    unique_ptr <A> p (new A);  //当test1 函数结束时会自动释放 p 所指向的堆空间
    //定义一个智能指针q指向 p 
    unique_ptr <A> q = p; //错误的unique_ptr 是唯一的智能指针 
}

int main() {
 
    test(); //test 函数结束，普通指针不会自动释放 
    test1(); //test 函数结束，智能指针会自动释放 
    return 0;
}

shared_ptr 例子：（共享型）

//头文件
#include <iostream>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex> 

using namespace std;

class A {
public:
    A() { cout << "A init"  << endl; }
   ~A() {
       cout << "A delete" << endl;
   }
};
//测试 
void test(){
   cout << "test" << endl;
    //使用普通指针
   A *p = new A;
}

void test1()
{
    cout << "test1" << endl;
    //使用智能指针
    shared_ptr <A> p(new A);  //当test1 函数结束时会自动释放 p 所指向的堆空间

    cout << p.get()  << endl;  //返回指针所指向的地址 

    cout << p.use_count() << endl;//返回指针的记数
    //定义一个智能指针q指向 p 
    shared_ptr<A> q=p; //shared_ptr不是独占可以不断叠加

    cout << p.get()  << endl;  //返回指针所指向的地址
 
    cout << p.use_count() << endl;//返回指针的记数

}

int main() 
{
    test(); 
    test1();
    //自定义删除器
    std::shared_ptr<int> ptr(new int, [](int *p){ cout << "delete"<<p<<endl; delete p; });

    //打印指针所指向的地址 
    cout << ptr.get() << endl; 
   return 0;
}

补充：自定义删除器

std::shared_ptr <int> ptr( new int, [] (int *p) { 
    delete p; } );

（1）不要用普通指针初始化多个智能指针，会出现 double_free. 
   // int *q =  new  int; .
    shared_ptr<int> q(new int);
    shared_ptr<int> p(q);
    shared_ptr<int> pp(q);

（2）尽量使用make_shared，少用new。

（3）不要delete get() 返回来的裸指针。

（4）不是new出来的空间要自定义删除器。

6、类型转换

旧式类型转换: 
(数据类型)变量名; // C语言风格类型转换 

新式转换:
const_cast<数据类型>(变量名);
static_cast<数据类型>(变量名);
dynamic_cast<数据类型>(变量名);

新式转换是C++的全新特性，这几个转换关键字含义如下：
const_cast : 专用于去除指针或引用的 const 属性
              1.const_cast 只能作用于指针或引用类型 
    
static_cast : 与旧式转换相近，但提供了更易于查找的语法，并能有效识别不兼容类型。
      		  1.主要用于内置数据类型之间的相互转换。如:char ,short , int , ..... 
          
dynamic_cast : 专用于父子类的类型转换
    		  1.将基类的指针或引用安全地转换成派生类的指针或引用,但是基类必须有虚函数

 reinterpret_cast

功能：与C语言一样任意转换.

reinterpret_cast <type> (expression)

非常激进的指针类型转换，在编译期完成，可以转换任何类型的指针，所以极不安全。非极端情况不要使用。

int *ip;
char *pc = reinterpret_cast<char*>(ip);

7、lambda表达式（QT上的槽会使用）

语法:
auto func = [capture] (params) opt -> ret 
            { func_body; };

func是可以当作lambda表达式的名字，作为一个函数使用
capture是捕获列表
params是参数表
opt是函数选项(mutable之类)
ret是返回值类型
func_body是函数体。
  
    
capture是捕获列表:
[]不捕获任何变量
[&]引用捕获，捕获外部作用域所有变量，在函数体内当作引用使用,可以修改值
[=]值捕获，捕获外部作用域所有变量，在函数内内有个副本使用  ,不可以修改值
[=, &a]值捕获外部作用域所有变量，按引用捕获a变量
[a]只值捕获a变量，不捕获其它变量
[this]捕获当前类中的this指针
    
opt选择:
int a = 0;
auto f1 = [=](){ return a; };    值捕获a
cout << f1() << endl;
auto f2 = [=]() { return a++; };          修改按值捕获的外部变量，error
auto f3 = [=]() mutable { return a++; };  添加mutable 选项可以修改

lambda 表达式的应用 

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

int main() {
    list<int> vec;
    vec.push_back(10);
    vec.push_back(45);
    vec.push_back(4);
    vec.push_back(48);
    vec.sort(); //排序
    //枚举
    for(int i:vec){
        cout << i << endl;
    }
	//自定义排序的规则 
    vec.sort( [] ( int a,int b ) { return a>b; } );
    //枚举
    for(int i:vec){
        cout << i << endl;
    }
}

demo

//利用lambada表达式实现两个数相加
#include<iostream>
using namespace std;

int main()
{
    int a=10;
    int b=20;
    int sum;
方法1，利用capture捕获
    [&a,&b,&sum](){  //或者直接[&]
        sum = a+b; 
    }();    //()调用函数
    cout << sum << endl;
方法1.1，用mutable修改值
    [=]() mutable{
        a = 22;
        b = 33;
        cout << a+b << endl;
    }();

方法2，利用opt选择
    auto f1 = [](int a1,int b1){    //(里面是参数列表)
        int sum1 = a1 + b1;
        return sum1;          //返回
    };
    cout << f1(11,22) << endl;  //像普通函数一样传参
方法2.1 外部调用
    int x=1,y=2;
    auto f2 = [&x,&y](){
        x = 10;
        y = 20;
        return x+y;
    };
    cout << f2() << endl;
方法2.2 (传参)
    [](int x1,int y1){
        x1 = 10;
        y1 = 20;
        return x1+y1;
    }(x,y);

}

总结：

1、c++的异常处理是为了提高程序员工作效率，它是先把错误放在后面解决，先完成一个个模块，因为c++有良好的封装性，一个功能有问题不会影响其他功能的实现，因此比error好。

2、c++11的新特性采用了一些新的方法，如auto，在使用迭代器的时候就不用输入很长的数据类型，它能自动转换，提高效率。如枚举循环，以前是python等脚本编程才有的特性，在2011年c++推出，减少程序员代码量。

3、lambda表达式Lambda表达式就是对函数式接口中抽象方法的实现,是对其匿名内部类的一个简写,只保留了方法的参数列表和方法体,其他的成分可以省略。不用想函数名，提高执行效率。

4、智能指针的使用方便了程序员，new完之后不用担心内存泄露，造成错误。随机数的功能适用游戏中，比较随机。final & override 提前把需要的写好，避免造成编译错误。

c++的内容基本就是这些，进阶的话要写一些小游戏和项目，下一阶段是QT，未完待续...

open_python
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C++:程序设计原理与实践》
08-24
第16章 图形用户界面 第三部分 数据结构和算法 第17章 向量和自由空间 第18章 向量和数组 第19章 向量、模板和异常 第20章 容器和迭代器 第21章 算法和映射 第四部分 拓宽视野 第22章 理念和历史 第23章 文本处理 第...
C/C++ 异常（ std::exception）
17岁boy的博客
11-27 1万+
C++提供异常主要是为了分割库异常与调用者之间的分割 平常当我们开发一个lib库时，一般lib库里的函数发生异常都会通过返回值来告诉用户，但是这样的开发属实有点过于麻烦了 如： int test(){ //发生错误1 return 1; //发生错误2 return 2 } 上面一个名为test的函数发生了异常，通过num数字来表示异常类型，这样的情况下调用者还要去翻阅手册去查查你这个返回到底是什么意思，在开发期间极其耗费时间，如果能够很直观的报出错误会很方便，但是
std::exception的使用
南宫封清的博客
09-24 5070
std::exception：标准异常类的基类，其类的声明在头文件<exception>中。所有标准库的异常类均继承于此类，因此通过引用类型可以捕获所有标准异常。 std::exception类定义了无参构造函数、拷贝构造函数、拷贝赋值运算符、一个虚析构函数和一个名为what的无参虚成员。其中what函数返回一个const char*，该指针指向一个以null结尾的字符数组，并且确保不会抛出任何异常，该字符串的目的是提供关于异常的一些文本信息。除析构函数外，其它函数均通过关键字noexcept
C++/C++11中std::exception的使用
热门推荐
网络资源是无限的
10-21 5万+
C++/C++11中std::exception的使用
【C++ 异常】深入探究C++的stdexcept类库
最新发布
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
09-17 458
在C++编程中，异常处理是一个不可或缺的部分。C++标准库提供了一组用于异常处理的标准类，这些类都定义在``头文件中。本文将深入探讨这些异常类，以及它们如何与C++的异常处理机制相结合。
std::exception自定义异常捕获类
cfl997
05-24 609
在这个例子中，我们定义了一个自定义的异常类 `MyException`，它继承自 `std::exception`。在 `main()` 函数中，我们通过捕获 `std::exception` 引用来捕获任何继承自 `std::exception` 的异常，并打印出异常消息。捕获的类型为 `const std::exception&`，以便可以捕获任何继承自 `std::exception` 的异常。2. 创建自定义异常类 `MyException`，并继承自 `std::exception`。
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
第16章 图 16.1 基本概念 16.2 应用和更多的概念 16.3 特性 16.4 抽象数据类型graph 16.5 无权图的描述 16.5.1 邻接矩阵 16.5.2 邻接链表 16.5.3 邻接数组 16.6 加权图的描述 16.7 类实现 16.7.1 不同的类 16.7.2 ...
3.C++程序设计语言.第1～3部分.原书第4版 中文版有详细书签2016
05-16
《C 程序设计语言》（原书第4版）是C 领域最经典的参考书，介绍了C 11的各项新特性和新功能。全书共分四部分。第一部分（第1~5章）是引言，包括C 的背景知识，C 语言及其标准库的简要介绍；第二部分（第6~15章）介绍...
C++ Primer中文版（第5版）李普曼 等著 pdf 1/3
02-24
　第16章 模板与泛型编程 577 　16.1 定义模板 578 　16.1.1 函数模板 578 　16.1.2 类模板 583 　16.1.3 模板参数 592 　16.1.4 成员模板 595 　16.1.5 控制实例化 597 　16.1.6 效率与灵活性 599 　16.2 模板实参...
-C++参考大全(第四版) (2010 年度畅销榜
12-08
第16章 继承 16.1 基类访问控制 16.2 继承和保护成员 16.3 继承多个基类 16.4 构造函数、析构函数和继承 16.5 准许访问 16.6 虚基类 第17章 虚函数与多态性 17.1 虚函数 17.2 继承虚属性 17.3 虚函数是分层的 17.4 ...
C++ 异常处理 std::exception
mayue_web的博客
02-22 5299
异常是程序在执行期间产生的问题。C++ 异常是指在程序运行时发生的特殊情况，比如尝试除以零的操作。 异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：try、catch、throw。 throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。 catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常。 tr...
C++ 异常机制详解
余识-
04-11 2141
C/C++教程C++中的异常处理机制可以帮助我们处理程序在运行时可能会遇到的异常情况，比如内存分配错误、文件打开失败等。当程序运行到某一处出现异常时，程序会立即跳转到相应的异常处理代码。C++中的异常处理使用try-catch语句实现，try语句块中包含可能抛出异常的代码，catch语句块用来捕获并处理异常。当程序执行到throw语句时，就会抛出一个异常，并跳转到最近的catch语句块处理异常。try {// 可能抛出异常的代码 } catch(exception & e) {// 处理异常 }
std::exception的使用，c++异常
sun007700的专栏
09-15 160
std::exception的使用_1390811049的博客-CSDN博客
[C++]异常笔记
weixin_51654781的博客
06-11 739
关于异常的复习笔记
C++异常处理详解 看这一篇就够了
lifesize的博客
01-12 3178
在程序运行的过程中，我们不可能保证我们的程序百分百不出现异常和错误，那么出现异常时该怎么报错，让我们知道是哪个地方错误了呢? C++中就提供了异常处理的机制。
C++ 关于异常捕获的槽点
Coder----Allen----Coder
04-15 677
本来想要一个像.net那样的异常捕获try{}catch(Exception ex){//"几乎能够捕获各种异常，只需要将ex里面的信息写到日志里面就行了，看看日志就知道问题大概在哪里"}；感觉.net还是挺方便的与是相当然的想在C++的项目里也这样做，然后发现事实并不行。 首先，C++里面的异常类关系是这样的 详细的说明可以看菜鸟教程，我经常看。哈哈哈哈。 C++ 异常处理 | 菜鸟教程 我的目的就是把异常写到本地日志，所以我就不关心这么多继承了，直接使用基类std::exception; .
C++ 11try catch 异常处理
kingforyang的博客
01-08 1686
C++ 11异常处理1、异常处理2、异常抛出2.1、提前结束函数2.2、栈展开2.3、未捕获异常3、资源回收3.1、临时对象回收3.2、析构函数默认是noexcept4、构造函数初始值的异常5、异常的类层次 1、异常处理 异常处理（exception handing）机制可以将问题的检测和问题的解决过程分离开。程序的一部分复制检测问题的出现，然后解决问题的任务传递给程序的另外一部分。 2、异常抛出 程序通过抛出（throw）一条表达式来引发一个异常。被抛出的表达式类型及当前的调用链共同决定了那一段处理代码将
c++中的exception
qq_32783703的博客
03-10 1564
c++中的exception std::exception std::exception类定义了无参构造函数、拷贝构造函数、拷贝赋值运算符、一个虚析构函数和一个名为what的无参虚成员。其中what函数返回一个const char*，该指针指向一个以null结尾的字符数组，并且确保不会抛出任何异常，该字符串的目的是提供关于异常的一些文本信息。除析构函数外，其它函数均通过关键字noexcept说明此函数不会抛出异常。 例子： #include <cctype> #include <iostr
c++ std::exception,std::logic_error 异常的使用方法
hjjdebug的专栏
11-23 2567
/显示了字符串类可以直接用+来连接。//exception 用法,如此访问异常。catch(exception &ex) // exception 的用法,如此接受异常。//exception 用法, 如此构造和抛出异常。在/usr/include/c++/9/stdexcept 文件中定义.c++ logic_error() 异常的使用方法。
深入理解c++11:c++11新特性解析与应用 pdf 脚本之家
05-11
《深入理解C++11:C++11新特性解析与应用》是一本C++11新特性的介绍和应用案例的书籍。该书主要分为三部分，第一部分介绍了C++11的新特性，第二部分是应用场景解析，第三部分则是深入理解C++11。 第一部分介绍了C++...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值