从小函数和小类看大设计----小话c++(4)

于 2012-06-01 13:15:18 发布
阅读量2.7k 收藏 2
点赞数 3
分类专栏： 小话c++ 文章标签： c++ class 编译器 function xcode4 汇编
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxsjabcabc/article/details/7622142
版权

[Mac 10.7.1  Lion  Intel-based  x64  gcc4.2.1  xcode4.2]


大道理大家都会说，因为书上到处都会写。

不喜欢讲大道理，道理自在真实的事实中。


Q： 如果需要提供一个计算两个元素较大值的模块，该提供什么样的代码？

A： 当然，不能轻易将元素认为是整形，这样可能导致很多时候无法使用。既然如此，模板成为一种很好地选择。


Q： 就类似如下代码么？

template<class T>
T   max(T a, T b)
{
    return a > b ? a : b;
}

A： 当然，这个代码的逻辑是没错的。不过欠缺对于元素为对象的考虑，那样的话，传参可能耗用可以节省的空间和时间。


Q： 那就修改为如下：

template<class T>
T   max(T &a, T &b)
{
    return a > b ? a : b;
}

A： 根据此例子，写如下测试代码： 
#include <iostream>

using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

namespace me
{

    template<class T>
    T   max(T &a, T &b)
    {
        return a > b ? a : b;
    }
    
}

int main (int argc, const char * argv[])
{
    me::max(1, 2);
    return 0;
}

很不幸，出现了编译错误： 
No matching function for call to 'max'
Candidate function [with T = int] not viable: no known conversion from 'int' to 'int &' for 1st argument

意思就是参数1无法和int &进行适当的转换。这个可以理解，因为max的参数形式为T &，它代表外部传入的一个变量，可能内部会修改。但是却传入了整形字面量1,这让编译器很为难。const引用也就有它的用处了。


Q： 再次修改，如下：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

namespace me
{

    template<class T>
    T   max(const T &a, const T &b)
    {
        return a > b ? a : b;
    }
    
}

int main (int argc, const char * argv[])
{
    me::max(1, 2);
    return 0;
}

编译，ok了。

A： 返回值为T类型，它可能需要构造，为何不把返回值变成const T &类型呢？


Q： 问题是函数返回值为const T &类型，可行吗？

A： 首先，函数返回值只可能当做右值，所以用T &作为返回值类型是可行的； 同样，用const修饰依然不会让外部可能具有的赋值操作出现问题，const对象可以赋值给非const对象。再者，返回的为传入的a或者b，不会出现返回局部引用的问题。


Q： 修改如下：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

namespace me
{

    template<class T>
    const T& max(const T& a, const T& b)
    {
        return a > b ? a : b;
    }
    
}

int main (int argc, const char * argv[])
{
    int ret = me::max(1, 2);
    return 0;
}

编译没问题。


A： 如果，a和b都是对象，那么此函数可以通过编译的前提是T具有重载大于运算符的函数。但是在STL中，很多代码已经默认将重载小于和重载等于运算符作为了标准，即在>, < , ==, >=, <=, !=这些运算符中，只需要重载<和==运算符即可把其它的形式用已有的重载来实现。所以，代码可以修改为使用<运算符。


Q： 如下：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

namespace me
{

    template<class T>
    const T& max(const T& a, const T& b)
    {
        return a < b ? b : a;
    }
    
}

int main (int argc, const char * argv[])
{
    int ret = me::max(1, 2);
    COUT_ENDL(ret)
    return 0;
}

A： 对于max函数，它的实现很简单，使用一下inline不失为一种好选择。 
#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

namespace me
{

    template<class T>
    inline 
    const T& max(const T& a, const T& b)
    {
        return a < b ? b : a;
    }
    
}

int main (int argc, const char * argv[])
{
    int ret = me::max(1, 2);
    COUT_ENDL(ret)
    return 0;
}

Q： mac系统自带的STL中max函数代码是什么样的？

A： 如下：

  template<typename _Tp>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {
      // concept requirements
      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
      //return  __a < __b ? __b : __a;
      if (__a < __b)
	return __b;
      return __a;
    }

Q： 正如刚刚所说，可以为对象重载<和==运算符，其它几种相关的关系运算符可以通过它们来实现，具体写代码的时候，难道每个类依然需要实现其它几种重载函数(虽然仅仅是编写<和==运算符操作的变形)吗？

A： 正因为，其它几种运算符的操作是类似的，可以把它们全部抽象出来，使用模板实现。如下：

    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }

    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }

    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }

    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }

当然这些代码可以不用再写一遍了，可以参考std命名空间内rel_ops命名空间中的实现代码。


Q： 对于类构造函数中的初始化列表，它的好处在哪里？

A： 如下例子：

#include 
  
  
   
   
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

  
  
class Student
{
public:
    Student(int age)
    {
        _age = age;
    }
    ~Student(){ }
    
public:
    int age() { return _age; }
    int age() const { return _age; }
    
private:
    int _age;
};

int main (int argc, const char * argv[])
{
    Student s(21);
    return 0;
}

编译，得到Student构造函数的汇编代码： 

0x0000000100000cdc <_ZN7StudentC1Ei+0>:	push   %rbp
0x0000000100000cdd <_ZN7StudentC1Ei+1>:	mov    %rsp,%rbp
0x0000000100000ce0 <_ZN7StudentC1Ei+4>:	mov    %rdi,-0x8(%rbp)
0x0000000100000ce4 <_ZN7StudentC1Ei+8>:	mov    %esi,-0xc(%rbp)
0x0000000100000ce7 <_ZN7StudentC1Ei+11>:	mov    -0x8(%rbp),%rax
0x0000000100000ceb <_ZN7StudentC1Ei+15>:	mov    -0xc(%rbp),%ecx
0x0000000100000cee <_ZN7StudentC1Ei+18>:	mov    %ecx,(%rax)
0x0000000100000cf0 <_ZN7StudentC1Ei+20>:	pop    %rbp
0x0000000100000cf1 <_ZN7StudentC1Ei+21>:	retq

修改Student类构造函数变成如下： 

Student(int age):_age(age) { }

再次编译，得到它的汇编形式： 

0x0000000100000cdc <_ZN7StudentC1Ei+0>:	push   %rbp
0x0000000100000cdd <_ZN7StudentC1Ei+1>:	mov    %rsp,%rbp
0x0000000100000ce0 <_ZN7StudentC1Ei+4>:	mov    %rdi,-0x8(%rbp)
0x0000000100000ce4 <_ZN7StudentC1Ei+8>:	mov    %esi,-0xc(%rbp)
0x0000000100000ce7 <_ZN7StudentC1Ei+11>:	mov    -0x8(%rbp),%rax
0x0000000100000ceb <_ZN7StudentC1Ei+15>:	mov    -0xc(%rbp),%ecx
0x0000000100000cee <_ZN7StudentC1Ei+18>:	mov    %ecx,(%rax)
0x0000000100000cf0 <_ZN7StudentC1Ei+20>:	pop    %rbp
0x0000000100000cf1 <_ZN7StudentC1Ei+21>:	retq

可以发现二者是一致的，说明初始化列表不是神秘的不行，在这里二者作用一致。当然这是对于简单的类型。


Q： 对于复杂的类型，是否依然一致呢？

A： 如下代码：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class Person
{
public:
    Person() { }
    Person(char sex):_sex(sex)
    {
        std::cout << "enter Person construct function..." << std::endl;
    }
    ~Person() { }
    Person(const Person& p)
    {
        std::cout << "enter Person copy construct function..." << std::endl;
        _sex = p._sex;
    }
    
    Person& operator=(const Person& p)
    {
        std::cout << "enter Person assign construct function..." << std::endl;
        if(&p != this)
        {
            _sex = p._sex;
        }
        return *this;
    }
    
private:
    char _sex;
};

class Student
{
public:
    Student(int age, Person &p):_age(age), _p(p) 
    {
        
    }
    ~Student(){ }
    
public:
    int age() { return _age; }
    int age() const { return _age; }
    
private:
    int     _age;
    Person  _p;
};

int main (int argc, const char * argv[])
{
    Person  p('m');
    Student s(21, p);
    return 0;
}

运行结果：

可以看到，除了p对象单独调用构造函数外，s对象的构造对于Person类仅仅调用了拷贝构造函数。


Q： 如果不是采用初始化列表呢？

A： 修改代码如下：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class Person
{
public:
    Person() { }
    Person(char sex):_sex(sex)
    {
        std::cout << "enter Person construct function..." << std::endl;
    }
    ~Person() { }
    Person(const Person& p)
    {
        std::cout << "enter Person copy construct function..." << std::endl;
        _sex = p._sex;
    }
    
    Person& operator=(const Person& p)
    {
        std::cout << "enter Person assign construct function..." << std::endl;
        if(&p != this)
        {
            _sex = p._sex;
        }
        return *this;
    }
    
private:
    char _sex;
};

class Student
{
public:
    Student(int age, Person &p):_age(age)
    {
        _p = p;
    }
    ~Student(){ }
    
public:
    int age() { return _age; }
    int age() const { return _age; }
    
private:
    int     _age;
    Person  _p;
};

int main (int argc, const char * argv[])
{
    Person  p('m');
    Student s(21, p);
    return 0;
}

运行结果如下：

可以发现，它和上面的执行结果的差距是：它多执行了一次构造函数。这也正是可能导致效率降低的原因。同理，如果构造函数参数不是Person引用，是Person类型的话，同样也有类似的差距。同时，也可以看出初始化列表上构造子对象和在构造函数内部构造的区别。


Q： 这么说来，是不是如果采用初始化列表的形式的话，Person构造函数的默认构造函数可以不用写了？

A： 是的。如下代码，不采用初始化列表的方式，Person的默认构造函数没有写出导致编译错误：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class Person
{
public:
    Person(char sex):_sex(sex)
    {
        std::cout << "enter Person construct function..." << std::endl;
    }
    ~Person() { }
    Person(const Person& p)
    {
        std::cout << "enter Person copy construct function..." << std::endl;
        _sex = p._sex;
    }
    
    Person& operator=(const Person& p)
    {
        std::cout << "enter Person assign construct function..." << std::endl;
        if(&p != this)
        {
            _sex = p._sex;
        }
        return *this;
    }
    
private:
    char _sex;
};

class Student
{
public:
    Student(int age, Person &p):_age(age)
    {
        _p = p;
    }
    ~Student(){ }
    
public:
    int age() { return _age; }
    int age() const { return _age; }
    
private:
    int     _age;
    Person  _p;
};

int main (int argc, const char * argv[])
{
    Person  p('m');
    Student s(21, p);
    return 0;
}

编译错误： 

No matching function for call to 'Person::Person()'

Q： 构造函数为什么没有返回值？

A： 问题是有返回值，返回什么。假设返回一个整数，那么例如Person p = Person('m');之类的代码，就类似把一个整数赋值给变量p，这如何合理呢？


Q： 析构函数为什么也没有返回值？

A： 如果是函数的局部对象，c++规定局部对象最后的析构由编译器生成对应的代码，既然由编译器生成对应的代码，那么程序员怎么再取到返回值？


Q： 为什么不建议在构造函数中抛出异常？

A： 因为异常机制导致执行路径改变，最终析构函数很可能不会被执行，导致内存泄露等问题。如下代码：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class Test
{
public:
    Test()
    {
        std::cout << "Test is called..." << std::endl;
        throw 1;
    }
    
    ~Test()
    {
        std::cout << "~Test is called..." << std::endl;
    }
};

int main (int argc, const char * argv[])
{
    Test t;
    return 0;
}

运行结果：

可以看出，析构函数没有正常执行，而是输出了异常提示。当然，处理这种问题，可以使用auto_ptr来解决。


Q： 析构函数为什么不建议直接抛出异常？

A： 这同样来源于抛出异常后，此对象究竟是什么状态。到底是可以不用管对象了，还是得管，后面还要继续操作。这些不确定也使得标准可能让它变得让程序员更无法确定。当然，不同的编译器对于析构函数抛出异常是否直接调用terminate也不尽相同，如下一个测试代码：

#include <iostream>
using namespace std;

#define COUT_ENDL(str)      std::cout << #str << " is " << (str) << std::endl;

class Test
{
public:
    Test()
    {
        std::cout << "Test is called..." << std::endl;
    }
    
    ~Test()
    {
        std::cout << "~Test is called..." << std::endl;
        throw 1;
    }
};

int main (int argc, const char * argv[])
{
    try
    {
        Test *t = new Test;
        delete t;
    }
    catch(...)
    {
        std::cout << "catch exception..." << std::endl;
    }
    
    int i = 1;
    COUT_ENDL(i)
    
    return 0;
}

运行结果：

它执行到了后面的输出i的代码。


Q： 那么，可能在构造函数和析构函数中抛出的异常，该在哪里处理呢？

A： 其实，构造完毕后，在其它函数对对象的处理可以进行相关判断，来确定是否已经发生了问题。析构函数可能出现异常的地方同样可以使用标志信息来记录传递到外层。


xichen

2012-6-1 13:16:44


程序员小迷
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
博客
git版本库瘦身你知道吗
04-25 451
1）在要上传代码的当前分支下创建孤儿分支（孤儿分支不继承任何git提交记录，但暂存区和工作目录中的文件不会被自动清空。2）远程代码库中已上传了许多git提交记录，需要将远程代码库中的git提交记录删除，以减少代码占用空间大小。
博客
动态代理有哪些神仙
04-25 395
它提供了更强大的代理功能，包括基于接口和基于类的代理，以及对方法拦截、字段操作等的全面支持。效率低，相比静态代理中 直接调用目标对象方法，动态代理则需要先通过Java反射机制 从而 间接调用目标对象的方法，因为 Java 的单继承特性（每个代理类都继承了 Proxy 类），即只能针对接口 创建 代理类，不能针对类创建代理类。动态代理分为基于接口的动态代理（被代理的对象必须实现一个或多个接口）和基于类的动态代理（这种代理方式不依赖于接口，而是直接基于类来实现，基于的类不能为final）。
博客
Java泛型你所不知道的点
04-24 392
Java语言中的泛型则不一样，它只在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（Raw Type，也称为裸类型）了，并且在相应的地方插入了强制转型代码，因此，对于运行期的Java语言来说，ArrayList＜int＞与ArrayList＜String＞就是同一个类，所以泛型技术实际上是Java语言的一颗语法糖，Java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。2）if(restrict instanceOf Restrict){}//不合法。
博客
如何让Linux服务器下基于Netty的应用程序支持几十万乃至百万长连接
04-23 478
ulimit 命令分软限制和硬限制，加-H就是硬限制，加-S就是软限制。默认显示的是软限制，如果运行ulimit 命令修改时没有加上-H或-S，就是两个参数一起改变。硬限制就是实际的限制，而软限制是警告限制，它只会给出警告。
博客
git撤销更改的门道
04-23 194
从 git show 命令的结果中可以看到，merge commit 的 parent 分别为 a111111 和 b222222，其中 a111111 代表 master 分支，b222222 代表 另一个 分支。
博客
BusyBox是何方神圣？
04-22 380
若不需root权限，可以复制到/vendor/bin目录或其他不需root的目录下。如果设备未root，可以将BusyBox命令安装到可以读、写、执行的普通目录下，如/data/tool/busybox，并添加到系统环境变量里。
博客
大厂面试：二叉搜索树如何获取其中第k小的结点
04-22 132
例如二叉搜索树（20，10，30，2，11，24，38）中第三小结点的值为11。二叉搜索树的中序遍历结果正好是从小到大排序好的，按照中序遍历顺序找第k个节点。微风不燥，阳光正好，你就像风一样经过这里，愿你停留的片刻温暖舒心。
博客
synchronized和ReentrantLock傻傻分不清楚
04-21 351
在锁对象的对象头里面有一个 ThreadID 字段，在第一次访问的时候 ThreadID 为空，然后JVM让其持有偏向锁，并将 ThreadID 设置为调用锁对象的线程 ID，再次进入的时候会先判断 ThreadID 是否与其线程 ID 一致，如果一致则可以直接使用，如果不一致，则升级偏向锁为轻量级锁，通过自旋来获取锁，不会阻塞，执行一定次数之后会升级为重量级锁（映射到操作系统提供的互斥锁Mutex Lock上）。当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
博客
Java中sleep()和wait()的区别知多少？
04-20 388
1.sleep可能会抛出InterruptedException（这通常发生在其他线程中断正在sleep的线程时，中断时会清空当前线程的中断状态）和IllegalArgumentException （当设置的睡眠时间为负时）。
博客
TCP断开连接为什么需要4次挥手？
04-19 570
客户端收到ACK后进入FIN-WAIT-2状态，收到服务端的FIN后发送最后一个ACK，并进入TIME-WAIT状态等待可能滞后的服务端数据报文，确认没有未送达的数据后，连接最终关闭。然后客户端接收到服务端发送的FIN，且服务端也收到了客户端发送的ACK之后，自此双方的数据通信完全结束。4次挥手过程提供了这样的机制，确保数据不会因为连接的关闭而丢失。总的来说，4次挥手是TCP协议为了确保连接可靠、有序地关闭而设计的，它允许双方都能完成数据的发送和确认，避免了数据丢失，并且确保了资源的合理释放。
博客
TCP为什么需要3次握手？
04-18 526
客户端向服务端发送一个表示建立连接的SYN报文段，服务端从IP数据报中提取出TCP SYN报文段，为该TCP连接分配需要的缓存和变量，并向客户端发送表示允许连接的报文段ACK。客户端在收到ACK报文段之后，也要给该连接分配缓存和变量，客户端向服务器再发送一个报文段ACK，表示对允许连接的报文段进行了确认。致力于C、C++、Java、Kotlin、Android、Shell、JavaScript、TypeScript、Python等编程技术的技巧经验分享。您的支持是我们为您提供帮助的最大动力。
博客
HTTP1.0、HTTP1.1、HTTP2.0、HTTP3.0傻傻分不清楚
04-17 605
不依赖TCP，基于QUIC协议。QUIC集成了TLS加密、流量控制、多路复用等功能，并在用户空间实现了快速连接建立、前向纠错、更精细的拥塞控制等特性。仍要求请求按顺序发送和接收,即存在"队头阻塞"问题,这意味着一个请求的延迟可能会阻塞后续的所有请求，影响整体加载速度。致力于C、C++、Java、Kotlin、Android、Shell、JavaScript、TypeScript、Python等编程技术的技巧经验分享。实现了多路复用连接共享，多个请求和响应可以在一个TCP连接上交错发送，解决了队头阻塞问题。
博客
优雅的反转链表你知道吗
04-16 246
重复将首节点的下一个节点调整到最前面，如链表1->2->3->4，调整过程为2->1->3->4，3->2->1->4，4->3->2->1。致力于C、C++、Java、Kotlin、Android、Shell、JavaScript、TypeScript、Python等编程技术的技巧经验分享。将原链表的元素从头到尾入栈后，从栈顶到栈底的元素的顺序即为原链表反转后的顺序。您的支持是我们为您提供帮助的最大动力。使链表从尾节点开始指向前一个节点。
博客
MinGW与Cygwin傻傻分不清楚
04-15 798
Cygwin 提供完整的类Unix 环境，是一个在Windows平台上运行的类UNIX模拟环境，它提供了一个UNIX模拟DLL以及在其上层构建的多种可以在Linux系统中找到的软件包。其主要目标是模拟UNIX/Linux环境，使得开发者可以在Windows上进行与UNIX/Linux相似的开发工作，或者将UNIX/Linux下的应用程序移植到Windows上。MinGW 环境下编译出来的程序，只能在Windows下跑，源码在linux环境下编译多半通不过，因为使用到了Windows下的API。
博客
获取字符串的全排列（去除字符串中2个字符相同时造成的重复）
04-15 319
致力于C、C++、Java、Kotlin、Android、Shell、JavaScript、TypeScript、Python等编程技术的技巧经验分享。您的支持是我们为您提供帮助的最大动力。以字符串abc为例，输出的结果为：abc、acb、bac、bca、cab、cba。以字符串aab为例，输出的结果为：aab、aba、baa。现有一个字符串，要打印出该字符串中字符的全排列。
博客
大厂面试：排列与组合傻傻分不清楚
04-14 200
求所有组合也就是abc各个位是否选取的问题，第一位2种可能，第二位2种可能，以此类推，一共有2^n种可能。用0表示不取，1表示选取，这样可以用110这样的形式表示ab。致力于C、C++、Java、Kotlin、Android、Shell、JavaScript、TypeScript、Python等编程技术的技巧经验分享。1）排列：全排列即字符不能重复，第一位有3种选择，第二位有2种选择，第三位有1种选择，所以最后有3*2*1=6种结果。
博客
大厂面试：获取字符串的可重复使用其中所有字符的全排列
04-13 155
现有一个字符串，要打印出该字符串中可重复使用该字符串中的所有字符的全排列。例如输入字符串ab，则打印出由字符a、b所能排列出来的可重复使用所有字符的所有字符串aa、ab、ba、bb。致力于C、C++、Java、Kotlin、Android、Shell、JavaScript、TypeScript、Python等编程技术的技巧经验分享。您的支持是我们为您提供帮助的最大动力。相当于每个位置都可以选择字符数组中的任何一个字符。可以基于递归算法来解决这个问题。
博客
大厂面试：获取字符串的全排列
04-12 259
现有一个字符串，要打印出该字符串中字符的全排列。例如输入字符串abc，则打印出由字符a、b、c所能排列出来的所有字符串abc、acb、bac、bca、cab和cba。致力于C、C++、Java、Kotlin、Android、Shell、JavaScript、TypeScript、Python等编程技术的技巧经验分享。您的支持是我们为您提供帮助的最大动力。可以基于回溯法来解决这个问题。
博客
Java泛型中 T 和 ? 傻傻分不清楚
04-11 1358
而 T 表示了集合[所有Java类型，包括String，Integer，Character等系统定义的，或者用户定义的类型]中的一个成员。由于容器的具体类型未知，如果往容器添加元素，无法确保添加进去的具体数据是该容器具体类型的子类还是父类，因此存在类型不安全问题，所以是不允许往容器里添加数据的。使用T时，Java的类型参数支持多重限定，如
博客
Java与Kotlin语言的特色之处
04-11 280
4.更安全的类型转换 在Java中，类型转换时常会出现运行时异常，而Kotlin通过使用"as?协程提供了一种轻量级的并发模型，可以避免传统线程和锁的使用，简化了并发编程的复杂性。致力于C、C++、Java、Kotlin、Android、Shell、JavaScript、TypeScript、Python等编程技术的技巧经验分享。一个try块可能捕获到多个异常，可以使用多个catch块分别处理每个异常，也可以使用一个catch块处理多个异常（多个异常使用管道符|分隔）。不支持八进制的字面常量。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值