C++ Primer Plus 学习笔记 第十五章 异常 abort() 返回错误提示，try-throw-catch exception和其派生类 RTTI 类型转换运算符

最新推荐文章于 2023-05-04 01:09:22 发布
最新推荐文章于 2023-05-04 01:09:22 发布
阅读量3k 收藏 3
点赞数
分类专栏： C++ 文章标签： C++ Primer Plus  异常 RTTI 类型转换运算符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/soulwyb/article/details/91411634
版权

abort() 来源于cstdlib 或 stdlib.h中 手动调用该函数来终止程序。 程序会跳出如下信息然后程序终止

untenable arguments to hmean()

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.

或者使用手动判断异常的方式 免去程序强制退出

error2.cpp

#include <iostream>
#include <cfloat>

bool hmean(double a, double b, double * ans);

int main()
{
  double x, y, z;
  std::cout << "Enter two numbers: ";
  while (std::cin >> x >> y)
  {
    if (hmean(x, y, &z))
      std::cout << "Hearmonic mean of " << x << " and " << y
                << " is " << z << std::endl;
    else
      std::cout << "One value should not be the negative "
                << "of the other - try again.\n";
      std::cout << "Enter next set of numbers <q to quit>: ";
  }
  std::cout << "Bye!\n";
  return 0;
}

bool hmean(double a, double b, double * ans)
{
  if (a == -b)
  {
// 程序示例是这样 但是这句表达式有毛用 至今看不出来
    *ans = DBL_MAX;
    return false;
  }
  else
  {
    *ans = 2.0 * a * b / ( a + b);
    return true;
  }
}

异常机制三部曲

引发异常，使用处理程序捕获异常，使用try块

这个在大部分的编程语言中都通用

throw() 抛异常

try() 可能会引发异常的代码块

catch() 异常捕获处理。

这个在JAVA Python中是一样的 只是关键字有区别

程序示例：

#include <iostream>
double hmean(double a, double b);

int main()
{
  double x, y, z;
  std::cout << "Enter two numbers: ";
  while(std::cin >> x >> y)
  {
    try{
      z = hmean(x, y);
    }
    catch(const char * s)
    {
      std::cout << s << std::endl;
      std::cout << "Enter a new pair of numbers: ";
      continue;
    }
    std::cout << "Harmonic mean of " << x << " and " << y
              << " is " << z << std::endl;
    std::cout << "Enter next set of numbers <q to quit>: ";
  }
  std::cout << "Bye!\n";
}

double hmean(double a, double b)
{
  if (a == -b)
    throw "bad hmean() arguments: a = -b not allowed";
  return 2.0 * a * b / (a + b);
}

如果没有捕获 C++ 默认调用abort()

将对象用作异常类型：

exc_mean.h

#include <iostream>


// bad_hmean异常是判断是否为相反数
// bad_gmean异常是判断参数是否小于0
class bad_hmean
{
  private:
    double v1;
    double v2;
  public:
    bad_hmean(double a = 0, double b = 0) : v1(a), v2(b) {}
    void mesg();
};

inline void bad_hmean::mesg()
{
  std::cout << "hmean(" << v1 << ", " << v2 << "): "
            << "invalid arguments: a = -b\n";
}

class bad_gmean
{
  public:
    double v1;
    double v2;
    bad_gmean(double a = 0, double b = 0) : v1(a), v2(b) {}
    const char* mesg();
};

inline const char* bad_gmean::mesg()
{
  return "gmean() arguments should be >= 0\n";
}

error4.cpp

#include <iostream>
#include <cmath>
#include "exc_mean.h"

// 在各自函数中引发异常
double hmean(double a, double b);
double gmean(double a, double b);
int main()
{
  using std::cout;
  using std::cin;
  using std::endl;

  double x, y, z;
  cout << "Enter two numbers: ";
  while (cin >> x >> y)
  {
    try{
      z = hmean(x, y);
      cout << "Harmonic mean of " << x << " and " << y
           << " is " << z << endl;
      cout << "Geometric mean of " << x << " and " << y
           << " is " << gmean(x, y)  << endl;
      cout << "Enter next set of numbers <q to quit>: ";
    }
// 通过捕获异常对象的引用类型来确定是用哪个catch
    catch(bad_hmean & bg)
    {
      bg.mesg();
      cout << "Try again.\n";
      continue;
    }
    catch(bad_gmean & hg)
    {
      cout << hg.mesg();
      cout << "Values used: " << hg.v1 << ", "
           << hg.v2 << endl;
      cout << "Sorry, you don't get to play any more.\n";
      break;
    }
  }
  cout << "Bye!\n";
  return 0;
}

double hmean(double a, double b)
{
  if (a == -b)
    throw bad_hmean(a, b);
  return 2.0 * a * b / (a + b);
}

double gmean(double a, double b)
{
  if (a < 0 || b < 0)
    throw bad_gmean(a, b);
  return std::sqrt(a * b);
}

异常规范：

noexcept 指出所在行的代码不会出现异常 例如：

double marm() noexcept; 

但是 谁能保证呢  发誓都没用的  所以 C++11也建议不要用这玩意儿

同时还有一个函数 noexcept() 用来判断操作数是否会引发异常。

 

栈解退：

正常的函数调用是这样的

如果调用时有异常是这样的：

示例图

程序示例

exc_mean.h

#include <iostream>

class bad_hmean
{
  private:
    double v1;
    double v2;
  public:
    bad_hmean(double a = 0, double b = 0) : v1(a), v2(b) {}
    void mesg();
};

inline void bad_hmean::mesg()
{
  std::cout << "hmean(" << v1 << ", " << v2 << "): "
            << "invalid arguments: a = -b\n";
}

class bad_gmean
{
  public:
    double v1;
    double v2;
    bad_gmean(double a = 0, double b = 0) : v1(a), v2(b) {}
    const char* mesg();
};

inline const char* bad_gmean::mesg()
{
  return "gmean() arguments should be >= 0\n";
}

error5.cpp

#include <iostream>
#include <cmath>
#include <string>
#include "exc_mean.h"

// 此DEMO是用来展示程序执行到哪一步
class demo
{
  private:
    std::string word;
  public:
    demo (const std::string & str)
    {
      word = str;
      std::cout << "demo " << word << " create\n";
    }
    ~demo()
    {
      std::cout << "demo " << word << " destroyed\n";
    }
    void show() const
    {
      std::cout << "demo " << word << " lives!\n";
    }
};

double hmean(double a, double b);
double gmean(double a, double b);
double means(double a, double b);


int main()
{
  using std::cout;
  using std::cin;
  using std::endl;

  double x, y, z;
  {
    demo d1("found in block in main()");
    cout << "Enter two numbers: ";
    while(cin >> x >> y)
    {
      try{
        z = means(x, y);
        cout << "The mean mean of " << x << " and " << y
             << " is " << z << endl;
        cout << "Enter next pair: ";
      }
      catch(bad_hmean & bg)
      {
        bg.mesg();
        cout << "Try again.\n";
        continue;
      }
      catch(bad_gmean & hg)
      {
        cout << hg.mesg();
        cout << "Values used: " << hg.v1 << ", "
             << hg.v2 << endl;
        cout << "Soryy, you don't get to play any more.\n";
        break;
      }
    }
    d1.show();
  }
  cout << "Bye!\n";
  cin.get();
  cin.get();
  return 0;
}

double hmean(double a, double b)
{
  if (a == -b)
    throw bad_hmean(a, b);
  return 2.0 * a * b / (a + b);
}

double gmean(double a, double b)
{
  if (a < 0 || b < 0)
    throw bad_gmean(a, b);
  return std::sqrt(a * b);
}

double means(double a, double b)
{
  double am, hm, gm;
  demo d2("found in means()");
  am = (a + b) / 2.0;
  try
  {
// 这里会捕获两次异常 一次是means自身捕获的 还有一次是它抛出去的然后由main()捕获的
    hm = hmean(a, b);
// 这里如果出现异常直接抛给main() 因为当前函数中没有对此异常进行捕获
    gm = gmean(a, b);
  }
  catch (bad_hmean & bg)
  {
    bg.mesg();
    std::cout << "Caught in means()\n";
// 这里抛给main() 一旦出现异常 函数后面的内容就不会执行。 如果函数有调用对象则直接调用解析函数
    throw;
  }
  d2.show();
  return (am + hm + gm) / 3.0;
}

执行结果

程序说明

异常的

异常的其他特性;

异常抛出来的总是对象的拷贝 以免对象是在函数中创建的临时对象而被释放掉造成错误

异常捕获使用引用的原因是 可以引用异常的派生类 这样可以捕获一系列的同一基类的异常 

但是 catch的排列顺序要与派生顺序相反。

exception类 

是一个抽象异常类

通过重新定义该类的what()函数 返回相应的字符串

通过此类派生了stdexcept类

该类又派生出两个系列的基类

logic_error和runtime_error

logic_error:

runtime_error

bad_alloc异常和new

new导致的分配问题会引发bad_alloc异常 <new>中已经包含了该异常的声明

程序示例：

#include <iostream>
#include <new>
#include <cstdlib>
using namespace std;

struct Big
{
  double stuff[20000];
};

int main()
{
  Big* pd;
  try{
    cout << "Trying to get a big block of memory:\n";
    pd = new Big[10000];
    cout << "Got past the new request:\n";
  }
  catch (bad_alloc & ba)
  {
    cout << "Caught the exception!\n";
    cout << ba.what() << endl;
    exit(EXIT_FAILURE);
  }
  cout << "Memory successfully allocated\n";
  pd[0].stuff[0] = 4;
  cout << pd[0].stuff[0] << endl;
  delete [] pd;
  return 0;
}

 

该程序我没有正常调出bad_alloc异常 因为在编译的时候 编译器就告诉我太大了 [手动无奈]

如果希望new失败的时候返回的是空指针 就这么写

int* pi = new (std::nothrow) int;

异常，继承和类

嗯。说的就是普通的类中带有异常内部类。

上代码吧：

sales.h

#include <stdexcept>
#include <string>

class Sales
{
  public:
    enum {MONTHS = 12};
// 声明内部异常类
    class bad_index: public std::logic_error
    {
      private:
        int bi;
      public:
        explicit bad_index(int ix, const std::string & s = "Index error in Sales object:\n");
        int bi_val() const {return bi;}
        virtual ~bad_index() throw() {}
    };
    explicit Sales(int yy = 0);
    Sales(int yy, const double * gr, int n);
    virtual ~Sales(){}
    int Year() const { return year;}
    virtual double operator[] (int i) const;
    virtual double & operator[] (int i);
  private:
    double gross[MONTHS];
    int year;
};

class LabeledSales : public Sales
{
  public:
// 声明内部异常类
    class nbad_index : public Sales::bad_index
    {
      private:
        std::string lbl;
      public:
        nbad_index(const std::string & lb, int ix,
            const std::string & s = "Index error in LabeledSales object\n");
        const std::string & label_val() const {return lbl;}
        virtual ~nbad_index() throw() {}
    };
    explicit LabeledSales(const std::string & lb = "none", int yy = 0);
    LabeledSales(const std::string & lb, int yy, const double * gr, int n);
    virtual ~LabeledSales() {}
    const std::string & Label() const {return label;}
    virtual double operator[](int i) const;
    virtual double & operator[](int i);
  private:
    std::string label;
};

sales.cpp

#include "sales.h"
#include <iostream>
using std::string;

Sales::bad_index::bad_index(int ix, const string & s)
    : std::logic_error(s), bi(ix)
{
}

Sales::Sales(int yy)
{
  year = yy;
  for (int i = 0; i < MONTHS; ++i)
    gross[i] = 0;
}

Sales::Sales(int yy, const double * gr, int n)
{
  year = yy;
  int lim = ( n < MONTHS) ? n : MONTHS;
  int i;
  for (i = 0; i < lim; ++i)
    gross[i] = gr[i];
  for (; i < MONTHS; ++i)
    gross[i] = 0;
}

double Sales::operator[](int i) const
{
  if (i < 0 || i >= MONTHS)
    throw bad_index(i);
  return gross[i];
}

double & Sales::operator[](int i)
{
  if (i < 0 || i >= MONTHS)
    throw bad_index(i);
  return gross[i];
}

LabeledSales::nbad_index::nbad_index(const string & lb, int ix,
    const string & s) : Sales::bad_index(ix, s)
{
  lbl = lb;
}

LabeledSales::LabeledSales(const string & lb, int yy) : Sales(yy)
{
  label = lb;
}

LabeledSales::LabeledSales(const string & lb, int yy, const double * gr, int n)
    : Sales(yy, gr, n)
{
  label = lb;
}

double LabeledSales::operator[](int i) const
{
  if (i < 0 || i >= MONTHS)
    throw nbad_index(Label(), i);
  return Sales::operator[](i);
}

double & LabeledSales::operator[](int i)
{
  if (i < 0 || i >= MONTHS)
    throw nbad_index(Label(), i);    
  return Sales::operator[](i);
}

user_sales.cpp

#include <iostream>
#include "sales.h"

int main()
{
  using std::cout;
  using std::cin;
  using std::endl;
  double vals1[12] =
  {
    1220, 1100, 1122, 2212, 1232, 2334,
    1884, 2393, 3302, 2922, 3002, 3544
  };

  double vals2[12] =
  {
    12, 11, 22, 21, 32, 34,
    28, 29, 33, 29, 32, 35
  };

  Sales sales1(2011, vals1, 12);
  LabeledSales sales2("Blogstar", 2012, vals2, 12);

  cout << "First try block:\n";
  try
  {
    int i;
    cout << "Year = " << sales1.Year() << endl;
    cout << "Label = " << sales2.Label() << endl;
// 这里迭代的时候到12下标就溢出 这里会捕获到异常
    for ( i = 0; i <= 12; i++)
    {
      cout << sales2[i] << " ";
      if (i % 6 == 5)
        cout << endl;
    }
    cout << "End of try block 1.\n";
  }
  catch(LabeledSales::nbad_index & bad)
  {
    cout << bad.what();
    cout << "Company: " << bad.label_val() << endl;
    cout << "bad index: " << bad.bi_val() << endl;
  }
  catch(Sales::bad_index & bad)
  {
    cout << bad.what();
    cout << "bad index: " << bad.bi_val() << endl;
  }
  cout << "done\n";
  return 0;
}

未捕获的异常和意外终止的异常

未捕获的异常系统会调用terminate()函数，该函数默认会调用abort()终止程序。

可以设置该函数使其执行自定义的函数

// terminate函数来源于exception
#include <exception>
using namespace std;

// 设置terminate函数调用的是指定的函数
set_terminate(myQuit);

void myQuit()
{
cout << "Terminating due to uncaught excetion\n";
exit(5);
}

意外发生的异常

可以指定异常贵方来指定捕获哪些异常：

// 声明抛出的异常类， 这是异常规范

double Argh(double, double) throw(out_of_bounds);

try{
    x = Argh(a, b);
}
// 在使用Argh函数的地方捕获指定异常
catch(out_of_bounds & ex)
{
    ...
}

这样很麻烦 如果是在二开祖传代码 鬼知道会爆出什么过异常  如果都按照异常规范来操作的话 一来可能异常会有很多，这样写估计要写两大行。二来 咱这么详细 总会有漏 。所以 C++11开始要抛弃这种规范。

这种意外导致的异常C++是调用unexpected()函数（名字很奇怪） 然后该函数调用terminate() 然后该函数默认调用abort()

同样 也有set_unexpected()函数 用来自定义意外异常函数

但是此方法与set_terminate()不一样，有限制：

意思就是 set_unexpected()中如果是引发异常 那就看该异常与throw()中的异常是不是一样 如果是的话就就用该throw()中的异常处理，也就是说将意外情况引导到指定的catch中。

如果异常不在异常规范中，且规范中没有std::bad_exception类型的异常 则调用terminate()

如果异常不在异常规范中，但是规范中有std::bad_exception类型的异常。 那将会抛std::bad_exception异常

通用方法：

#include <exception>
using namespace std;

set_unexpected(myUnexpected);

void myUnexpected()
{
    // 或者 throw();
    throw std::bad_exception();
}

double Argh(double, double) throw(out_of_bounds, bad_exception);
...
try{
    x = Argh(a, b);
}
catch(out_of_bounds & ex)
{
    ...
}
catch(bad_exception & ex)
{
    ...
}

异常注意事项

不要在模板中使用异常规范  因为涉及内存的动态分配问题

解决方案就是讲delete [] ar;反倒抛异常的语句前面

这说的是WINDOWS是么 - -

RTTI

运行阶段类型识别。 用来确定对象类型的

有三个元素

dynamic_cast：用来判断某个对象指针是否可以安全的转换为另一个对象的指针。如果可以，正常转换，如果不行，则返回空指针。格式：

Superb * pm = dynamic_cast<Superb *>(pg);

代码示例：

#include <iostream>
#include <cstdlib>
#include <ctime>

using std::cout;

class Grand
{
  private:
    int bold;
  public:
    Grand(int h = 0) : bold(h) {}
    virtual void Speak() const {cout << "I am a grand class!\n";}
    virtual int Value() const {return bold;}
};

class Superb : public Grand
{
  public:
    Superb(int h = 0) : Grand(h) {}
    void Speak() const {cout << "I am superb class!!\n";}
    virtual void Say() const
      { cout << "I hold the superb value of " << Value() << "!\n";}
};

class Magnificent : public Superb
{
  private:
    char ch;
  public:
    Magnificent(int h = 0, char c = 'A') :Superb(h), ch(c) {}
    void Speak() const {cout << "I am a magnificent class!!!\n";}
    void Say() const {cout << "I hold the character " << ch
                            << " and the integer " << Value() << "!\n";}
};

Grand * GetOne();

int main()
{
  std::srand(std::time(0));
  Grand * pg;
  Superb * ps;
  for ( int i = 0; i < 5; i++)
  {
    pg = GetOne();
    pg->Speak();
    if (ps = dynamic_cast<Superb *>(pg))
      ps->Say();
  }
  return 0;
}

Grand * GetOne()
{
  Grand* p;
  switch( std::rand() % 3)
  {
    case 0: p = new Grand(std::rand() % 100);
            break;
    case 1: p = new Superb(std::rand() % 100);
            break;
    case 2: p = new Magnificent(std::rand() % 100, 'A' + std::rand() % 26);
            break;
  }
  return p;
}

typeid运算符

判断两个对象是否同种类型

例子：

typeid(Magnificent) == typeid(*pg)（接收的参数可以是类名和结果为对象的表达式）

结果为true, 如果不同则返回false

如果pg是空指针 会引发bad_typeid异常。

type_info类：

程序示例

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <typeinfo>
using namespace std;

class Grand
{
  private:
    int bold;
  public:
    Grand(int h = 0) : bold(h) {}
    virtual void Speak() const {cout << "I am a grand class!\n";}
    virtual int Value() const {return bold;}
};

class Superb : public Grand
{
  public:
    Superb(int h = 0) : Grand(h) {}
    void Speak() const {cout << "I am superb class!!\n";}
    virtual void Say() const
      { cout << "I hold the superb value of " << Value() << "!\n";}
};

class Magnificent : public Superb
{
  private:
    char ch;
  public:
    Magnificent(int h = 0, char c = 'A') :Superb(h), ch(c) {}
    void Speak() const {cout << "I am a magnificent class!!!\n";}
    void Say() const {cout << "I hold the character " << ch
                            << " and the integer " << Value() << "!\n";}
};

Grand * GetOne();

int main()
{
  std::srand(std::time(0));
  Grand * pg;
  Superb * ps;
  for ( int i = 0; i < 5; i++)
  {
    pg = GetOne();
    cout << "Now processing type " << typeid(*pg).name() << ".\n";
    pg->Speak();
    if(ps = dynamic_cast<Superb *>(pg))
      ps->Say();
    if (typeid(Magnificent) == typeid(*pg))
      cout << "Yes, you're really magnificent.\n";
  }
  return 0;
}

Grand * GetOne()
{
  Grand* p;
  switch( std::rand() % 3)
  {
    case 0: p = new Grand(std::rand() % 100);
            break;
    case 1: p = new Superb(std::rand() % 100);
            break;
    case 2: p = new Magnificent(std::rand() % 100, 'A' + std::rand() % 26);
            break;
  }
  return p;
}

类型转换运算符

为了更严格的定义类型转换

C++添加了以下4中运算符

dynamic_cast: 这个前面说过了 就是转换前判定是否能够安全转换对象类型

const_cast： 这个只用于一次性。除了将const转换成非const（或转成volatile类型）使用之外 转换成其他类型的都将抛出异常

                        这个只针对非const 传入到要求const的函数形参中 ，如果本身是const变量的话那是返回空指针

程序示例：

#include <iostream>
using std::cout;
using std::endl;
void change(const int * pt, int n);

int main()
{
  int pop1 = 38383;
  const int pop2 = 2000;

  cout << "pop1, pop2: " << pop1 << ", " << pop2 << endl;
  change(&pop1, -103);
  change(&pop2, -103);
  cout << "pop1, pop2: " << pop1 << ", " << pop2 << endl;
  return 0;
}

void change(const int * pt, int n)
{
  int* pc;

  pc = const_cast<int *>(pt);
  *pc += n;
}

运行结果

static_cast： 这个是检测用于被转换的类与将要转换成的类之间有没有关联  是不是基-派生 或者间接基类，间接派生 如果是两个完全不相干的类 则会抛异常

reinterpret_cast：这种是用于转换一些莫名其妙但是有时候又用得到的类型转换：看例子吧

正常不这么干吧 这样转换 好奇怪。

C++中转换的限制：

总结：

@凌晨三点半
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++中的异常处理机制：abort、exit、exception类和try..catch语句块
aishuirenjia的博客
05-28 6858
程序运行时有时会遇到错误，导致程序无法正常运行下去，通常程序员会试图预防这种意外。C++异常处理为这种情况提供了一种功能强大而灵活的工具。这里会介绍四种，分别是： • 调用abort()函数及assert()函数 • 调用exit()函数 • 异常捕获机制try…catch… • exception类 一. 调用abort()函数及assert()函数 abort()函数的原型位于头文件cstdlib（或stdlib.h）中，其典型实现是向标准错误流（即cerr使用的错误流）发送abnormal p
abortonerror_开发中碰到的错误日记1
weixin_42231085的博客
01-15 296
记录开发中碰到的错误把一些碰到的错误都记录下来。随时更新吧！好记性，不如烂笔头。No resource found that matches the given name错误如下Error:(11, 31) No resource found that matches the given name (at 'layout_above' with value '@id/tv_base').emmm碰...
try catch语句中执行条件判断使用response.end时提示thread abort错误的解决方案
sxf359的博客
12-05 513
解决方案是将Response.End放到finally语句中，类似如下代码 ​ try        {            //读取数据库                        if (true)            //这里对读出来的值进行业务逻辑判断                        {                Respo
关于 delete[]
shandianling
09-27 604
通常在delete[]一个数组时，编译器要按顺序作如下两件事情：  　1. 对每个数组元素调用析构函数  　2. 释放对象数组所占内存  注意这是彼此独立的两步．  在第２步．编译器只需简单地把数组首地址告诉操作系统，操作系统内部有内存申请情况的记录（每个申请内存段的首地址，长度，etc..)，因此会正确地释放掉内存．注意整个数组所占内存是一次释放掉的，而不是每个元素释放一次．事实上，
Abort与当前执行指令相关吗？
m0_66300412的博客
05-04 260
Abort与当前执行指令相关吗？
C++ Primer Plus 学习笔记
最新发布
04-17
《C++ Primer Plus 学习笔记》是一份深入学习C++编程语言的宝贵资源，它涵盖了C++的基础语法以及标准模板库（STL）的使用。C++是一种强大的、通用的编程语言，由Bjarne Stroustrup在C语言的基础上发展而来，其设计...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
《C++ primer plus》读书笔记(一)
01-20
第一章 1、预处理器——#include将iostream文件内容添加到程序中。老式C头文件保留了扩展名.h，而C++头文件没有扩展名。 （有些C头文件被转换为C++头文件，去掉扩展名，并在前面加c，如cmath） 2、名称空间——相当...
《C++ primer plus》读书笔记(三)
09-04
《C++ Primer Plus》读书笔记(三)涵盖了C++编程中的关键概念，主要涉及程序的组织结构、编译过程、存储持续性、链接性、变量声明以及与内存管理相关的操作。以下是这些知识点的详细说明： 1. **C++程序的组成**： ...
《C++ Primer》隐式类类型转换学习整理
01-20
C++ Primer中有这样一句话：可以用单个实参来调用的构造函数定义了从形参类型到该类类型的一个转换。这句话用下面一段代码表示为： class A { A(B b);//单个实参的构造函数 func(A a); } ..... A a； B b; a.func...
从小白开始学C++ 异常（abort）
Enternalwiser的博客
08-26 1241
C++ 异常 abort try catch throw
异常捕获
KanG
07-04 4952
调用 abort 函数终止程序 调用 abort() 函数来终止发现异常的程序. abort() 函数将直接终止程序而不是首先返回到主函数(在 VC 下的入口函数 main[控制台] 或 WinMain[窗体程序])中 例子: #include #include double hmean(double a,double b) { if(a == -b) {
C++ abort() has been called错误
热门推荐
zhan_zhan1的博客
01-05 4万+
程序可以成功编译，说明没有语法问题，应是代码内部的问题，报错如下： abort() has been called：中止被调用，该错误出现有很多原因，查询了多条博客后，发现一卒2018博主已经在博客上总结了几条原因和解决办法，谢谢博主，借博主的思路成功解决问题。 原因： 1.非法指针访问和内存泄漏 2.设置的指针范围跟你运行的不对 3.指针访问内存越界出现问题。 4.因为不支持中文。 5.内存不...
ARM的Abort异常
04-15 4823
data abort exception:        data abort是arm异常的一种。当程序试图读或者写一个不合法的内存地址时发生（没有权限访问或者不存在的地址）， 可以通过以下方式计算不合法的内存地址：     R14(LR)-8得到导致data abort异常的指令，从指令的寄存器中得到需要操作的地址。     一般而言，导致这种异常的指令为STR,LDR（涉及到内存读写的
异常处理，abort()，exit()，返回错误码
Reid__的博客
08-27 4834
abort函数位于cstdlib头文件里，它会终止程序，并根据具体实现返回一个值给调用这个程序的系统或进程，而exit函数单纯终止程序，不会返回消息。 abort的具体实现： #include #include using namespace std; double hmean(double a,double b){ if(a==-b){ cout<<"aerror!a+b=0"
05-abort函数、自定义错误、 视图函数的返回值
weixin_33738555的博客
01-17 238
abort函数的使用 如果在视图函数执行过程中，出现了异常错误，我们可以使用abort函数立即终止视图函数的执行。通过abort函数，可以向前端返回一个http标准中存在的错误状态码，表示出现的错误信息。 使用abort抛出一个http标准中不存在的自定义的状态码，没有实际意义。如果abort函数被触发，其后面的语句将不会执行。其类似于python中raise。 # coding:ut...
mui. ajax报错，type为abort问题
Arya的博客
11-22 8124
问题描述： 开发调试过程中，在Hbuilder内调用mui.ajax，抛出异常，type为abort。解决：后来得知原因是不能使用localhost和127.0.0.7需要使用本机的IP地址，且手机和电脑要连同一无线，修改ajax的访问地址后，问题解决。
C#中的线程之Abort陷阱
pcd的博客
10-23 2万+
C#中的线程陷阱之Abort1.简介 C#中通常使用线程类Thread来进行线程的创建与调度，博主在本文中将分享多年C#开发中遇到的Thread使用陷阱。 Thread调度其实官方文档已经说明很详细了。本文只简单说明，不做深入探讨。 如下代码展示了一个线程的创建与启动 static void Main(string[] args) {
ARM/linux异常abort学习
04-15 1702
ARM定义了有七种异常，当有异常发生时，ARM会根据异常的类型自动执行异常向量表中的指令。 这几种异常具体如下： reset      SVC +0x00 undefine   UND +0x04 SWI        SVC +0x08 prefetch   ABT +0x0c data abort ABT +0x10 IRQ        IRQ +0x18 FIQ      
C++ Primer Plus 学习笔记：从入门到精通
以上只是C++基础的一部分，完整的《C++ Prime Plus》笔记包含了更多深入的主题，如指针、内存管理、类和对象的更复杂用法、模板、异常处理等。通过学习这些内容，读者可以逐步掌握C++编程，并能够编写出高效、可靠的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

@凌晨三点半

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

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

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

打赏作者

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

抵扣说明：

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

余额充值