C++类构造函数和析构函数

article/2025/10/2 6:08:34

11.3 类构造函数和析构函数

构造函数：是为了在定义对象时自动初始化其成员变量的值。

构造函数没有返回值，也没有被声明为void类型；因此，构造函数没有声明类型。

11.3.1 声明和定义一个构造函数

构造函数原型：在这里有个十分尴尬的情况，构造函数参数名和类的成员变量如果相同将会导致代码混乱，常见的解决方案就是加前缀或后缀：

//构造函数是这样，参数shares和share_val，如果类成员也是这样参数shares和share_val，将会导致混乱
Stock::Stock(const string & company, long shares, double share_val)
{...
}
//解决方案
class Stock
{private:string m_company;long m_shares;...orclass Stock
{private:string company_;long shares_;...
}

// constructor prototype with some default arguments
Stock(const std::string & co, long n = 0, double pr = 0.0);

构造函数定义：

// constructor definition
Stock::Stock(const std::string& co, long n, double pr)
{company = co;if (n < 0){std::cerr << "Number of shares can’t be negative; "<< company << " shares set to 0.\n";shares = 0;}elseshares = n;share_val = pr;set_tot();
}

11.3.2 使用构造函数

//下面这两种都是可以的嘿嘿
Stock food = Stock("World Cabbage", 250, 1.25);
Stock garment("Furry Mason", 50, 2.5);
//这个是结合了动态内存分配
Stock *pstock = new Stock("Electroshock Games", 18, 19.0);

11.3.3 默认构造函数

默认构造函数时在为提供显式初始值时，用来创建对象的构造函数。

//如果你没有给自定义类定义构造函数，那么系统会自动生成下面这个构造函数，称为默认构造函数
Stock::Stock() { }
//那么对于下面这个变量fluffy_the_cat，它的成员函数没有被初始化
Stock fluffy_the_cat; // uses the default constructor//如果自定义了构造函数，那么系统不再自动生成默认构造函数了，因此对于上面这句定义，系统将会报错
//因此需要自定义默认构造函数，有两种方式，一是给函数设置默认形参，如下所示：
Stock(const string & co = "Error", int n = 0, double pr = 0.0);
//二是自己定义一个无参数的默认构造函数
Stock::Stock() // default constructor
{company = "no name";shares = 0;share_val = 0.0;total_val = 0.0;
}//以下代码调用默认构造函数
Stock first; // calls default constructor implicitly
Stock first = Stock(); // calls it explicitly
Stock *prelief = new Stock; // calls it implicitly//以下代码调用其他构造函数
Stock first("Concrete Conglomerate"); // calls constructor

11.3.4 析构函数

析构函数就是在类名前加上。因此Stock类的析构函数为Stock()。另外，与构造函数一样，析构函数也可以没有返回值和声明类型。与构造函数不同的是，析构函数没有参数。

析构函数原型：

~Stock();

析构函数定义：

Stock::~Stock()
{
}

析构函数什么时候调用呢？--------析构函数是自动调用的

如果创建的时静态存储类对象，则其析构函数将在程序结束时自动被调用。如果创建的是自动存储类对象，则其析构函数将在函数执行完代码块时自动被调用。如果对象时通过new创建的，则它将驻留在栈内存或自由存储区中，当使用delete来释放内存时，其析构函数将自动被调用。最后，程序可以创建临时对象来完成特定的功能，在这种情况下，程序将在结束对该对象的使用时自动调用其析构函数。

构造函数有默认构造函数，如果用户没有自定义析构函数，系统将会生成一个默认析构函数。

11.3.5 自定义类举例

11.3.5.1 源文件及运行结果

头文件：

#pragma once
// stock00.h -- Stock class interface
// version 00
#ifndef STOCK00_H_
#define STOCK00_H_
#include <string>
class Stock
{
private:std::string company;long shares;double share_val;double total_val;void set_tot() { total_val = shares * share_val; }
public:// two constructorsStock(); // default constructorStock(const std::string& co, long n = 0, double pr = 0.0);~Stock(); // noisy destructorvoid buy(long num, double price);void sell(long num, double price);void update(double price);void show();
};
#endif

函数实现文件：

将文件名放在双引号而不是方括号中意味着编译器将在源文件所在的目录中搜索它。

// stock00.cpp -- implementing the Stock class
// version 00
#include <iostream>
#include "stock00.h"// constructors (verbose versions)
Stock::Stock() // default constructor
{std::cout << "Default constructor called\n";company = "no name";shares = 0;share_val = 0.0;total_val = 0.0;
}
Stock::Stock(const std::string& co, long n, double pr)
{std::cout << "Constructor using " << co << " called\n";company = co;if (n < 0){std::cout << "Number of shares can’t be negative; "<< company << " shares set to 0.\n";shares = 0;}elseshares = n;share_val = pr;set_tot();
}
// class destructor
Stock::~Stock() // verbose class destructor
{std::cout << "Bye, " << company << "!\n";
}
// other methods
void Stock::buy(long num, double price)
{if (num < 0){std::cout << "Number of shares purchased can’t be negative. "<< "Transaction is aborted.\n";}else{shares += num;share_val = price;set_tot();}
}
void Stock::sell(long num, double price)
{using std::cout;if (num < 0){cout << "Number of shares sold can’t be negative. "<< "Transaction is aborted.\n";}else if (num > shares){cout << "You can’t sell more than you have! "<< "Transaction is aborted.\n";}else{shares -= num;share_val = price;set_tot();}
}
void Stock::update(double price)
{share_val = price;set_tot();
}
void Stock::show()
{using std::cout;using std::ios_base;// set format to #.###ios_base::fmtflags orig =cout.setf(ios_base::fixed, ios_base::floatfield);std::streamsize prec = cout.precision(3);cout << "Company: " << company<< " Shares: " << shares << '\n';cout << " Share Price: $" << share_val;// set format to #.##cout.precision(2);cout << " Total Worth: $" << total_val << '\n';// restore original formatcout.setf(orig, ios_base::floatfield);cout.precision(prec);
}

main文件：

// usestck0.cpp -- the client program
// compile with stock00.cpp
#include <iostream>
#include "stock00.h"
int main()
{{//这个大括号是为了制造一个块，然后这个块呢可以使得在程序结束之前调用析构函数并在窗口显示文字//如果没有这个块，那么就不会看到Bye, NanoSmart!和Bye, Nifty Foods!的显示了using std::cout;cout << "Using constructors to create new objects\n";Stock stock1("NanoSmart", 12, 20.0); // syntax 1stock1.show();Stock stock2 = Stock("Boffo Objects", 2, 2.0); // syntax 2stock2.show();cout << "Assigning stock1 to stock2:\n";stock2 = stock1;//When you assign one object to another of the same class, by default C++ copies the contents of each data member of the source object to the corresponding data member of the target object.cout << "Listing stock1 and stock2:\n";stock1.show();stock2.show();cout << "Using a constructor to reset an object\n";stock1 = Stock("Nifty Foods", 10, 50.0); // temp objectcout << "Revised stock1:\n";stock1.show();cout << "Done\n";}return 0;
}

运行结果：

Using constructors to create new objects
Constructor using NanoSmart called
Company: NanoSmart Shares: 12Share Price: $20.00 Total Worth: $240.00
Constructor using Boffo Objects called
Company: Boffo Objects Shares: 2Share Price: $2.000 Total Worth: $4.00
Assigning stock1 to stock2:
Listing stock1 and stock2:
Company: NanoSmart Shares: 12Share Price: $20.000 Total Worth: $240.00
Company: NanoSmart Shares: 12Share Price: $20.000 Total Worth: $240.00
Using a constructor to reset an object
Constructor using Nifty Foods called
Bye, Nifty Foods!
Revised stock1:
Company: Nifty Foods Shares: 10Share Price: $50.000 Total Worth: $500.00
Done
Bye, NanoSmart!
Bye, Nifty Foods!D:\Prj\C++\Class_Defined\Debug\Class_Defined.exe (进程 4956)已退出，代码为 0。
要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
按任意键关闭此窗口. . .

11.3.5.2 注意事项

有些编译器可能出现以下结果：

Using constructors to create new objects
Constructor using NanoSmart called
Company: NanoSmart Shares: 12
Share Price: $20.00 Total Worth: $240.00
Constructor using Boffo Objects called
Bye, Boffo Objects! << additional line
Company: Boffo Objects Shares: 2
Share Price: $2.00 Total Worth: $4.00
...

原因是：

对于以下语句C++标准给了两种方式执行：

Stock stock2 = Stock ("Boffo Objects", 2, 2.0);

第一种是下面这样的：

Constructor using Boffo Objects called
Company: Boffo Objects Shares: 2

第二种是生成一个临时变量：调用构造函数来创建一个临时对象，然后将该临时对象复制到stock2中，并丢弃它。如果编译器使用的时这种方式，则将为临时对象调用析构函数，因此生成下面的输出：

Constructor using Boffo Objects called
Bye, Boffo Objects!
Company: Boffo Objects Shares: 2

生成上述输出的编译器可能立刻删除临时对象，但也可能会等一段时间，在这种情况下，析构函数的消息将会过一段时间才显示。
由此得出结论：

如果既可以通过初始化，也可以通过复制来设置对象的值，则应采用初始化方式。通常这种方式的效率更高。

11.3.6 移动语义

11.3.6.1 移动构造函数

对于构造函数的深复制，在某些情况下源数据将被删除而不需要副本，而且涉及到的内存比较大，此时编译器可以将数据的所有权转让给相关的变量，就避免了做大量无用功。

实际文件还留在原来的地方，而只是修改了记录；这种方法称为移动语义。

默认移动构造函数—系统自动生成，如果程序员提供了则使用程序员的版本。

Someclass::Someclass(Someclass &&); // defaulted move constructor

vector<string> vstr_copy1(vstr); // #1
vector<string> vstr_copy2(allcaps(vstr)); // #2

要实现移动语义，需要采取某种方式，让编译器直到什么时候需要复制，什么时候不需要。这就是右值引用发挥作用的地方。可定义两个构造函数。其中一个是常规复制构造函数，它使用const左值引用作为参数，这个引用关联到左值实参，如语句#1中的vstr；另一个是移动构造函数，它使用右值引用作为参数，这个引用关联到右值实参，如语句#2中allcaps(vstr)的返回值。复制构造函数可执行深复制，而移动构造函数只调整记录。在将所有权转移给新对象的过程中，移动构造函数可能修改其实参，这意味着右值引用参数不应是const。

如何实现移动语义：
1.右值引用让编译器知道何时可使用移动语义；
2.编写移动构造函数，使其提供所需的行为。
在这里插入图片描述

11.3.6.2 移动赋值运算符

移动赋值运算符删除目标对象中的原始数据，并将源对象的所有权转让给目标。
移动赋值运算符的参数不能是const引用，因为这个方法修改了源对象。

默认移动赋值运算符—系统自动生成，如果程序员提供了则使用程序员的版本。

Someclass & Someclass::operator=(Someclass &&); // defaulted move assignment

在这里插入图片描述

11.3.6.3 强制移动

使用头文件utility头文件中的std::move()函数将对象的类型强制转换为移动类型。

11.3.6.4 举例

code
useless.h

#pragma once
#ifndef _USELESS_H_
#define _USELESS_H_
#include <utility>
#include <iostream>
// interface
class Useless
{
private:int n; // number of elementschar* pc; // pointer to datastatic int ct; // number of objectsvoid ShowObject() const;
public:Useless();explicit Useless(int k);Useless(int k, char ch);Useless(const Useless& f); // regular copy constructorUseless(Useless && f); // move constructor~Useless();Useless operator+(const Useless& f)const;void ShowData() const;Useless& operator=(const Useless& f);// copy assignmentUseless& operator=(Useless&& f);// move assignment
};
#endif

useless.cpp

#include "useless.h"
using namespace std;// implementation
int Useless::ct = 0;
Useless::Useless()
{++ct;n = 0;pc = nullptr;cout << "default constructor called; number of objects: " << ct << endl;ShowObject();
}
Useless::Useless(int k) : n(k)
{++ct;cout << "int constructor called; number of objects: " << ct << endl;pc = new char[n];ShowObject();
}
Useless::Useless(int k, char ch) : n(k)
{++ct;cout << "int, char constructor called; number of objects: " << ct<< endl;pc = new char[n];for (int i = 0; i < n; i++)pc[i] = ch;ShowObject();
}
Useless::Useless(const Useless& f) : n(f.n)
{++ct;cout << "copy const called; number of objects: " << ct << endl;pc = new char[n];for (int i = 0; i < n; i++)pc[i] = f.pc[i];ShowObject();
}
Useless::Useless(Useless&& f) : n(f.n)
{++ct;cout << "move constructor called; number of objects: " << ct << endl;pc = f.pc; // steal addressf.pc = nullptr; // give old object nothing in returnf.n = 0;ShowObject();
}
Useless::~Useless()
{cout << "destructor called; objects left: " << --ct << endl;cout << "deleted object:\n";ShowObject();delete[] pc;
}
Useless Useless::operator+(const Useless& f)const
{cout << "Entering operator+()\n";Useless temp = Useless(n + f.n);for (int i = 0; i < n; i++)temp.pc[i] = pc[i];for (int i = n; i < temp.n; i++)temp.pc[i] = f.pc[i - n];cout << "temp object:\n";cout << "Leaving operator+()\n";return temp;
}
void Useless::ShowObject() const
{cout << "Number of elements: " << n;cout << " Data address: " << (void*)pc << endl;
}
void Useless::ShowData() const
{if (n == 0)cout << "(object empty)";elsefor (int i = 0; i < n; i++)cout << pc[i];cout << endl;
}Useless& Useless::operator=(const Useless& f) // copy assignment
{cout << "Entering operator=()\n";if (this == &f)return *this;delete[] pc;n = f.n;pc = new char[n];for (int i = 0; i < n; i++)pc[i] = f.pc[i];cout << "Leaving operator=()\n";return *this;
}Useless& Useless::operator=(Useless&& f) // move assignment
{cout << "Entering move operator=()\n";if (this == &f)return *this;delete[] pc;n = f.n;pc = f.pc;f.n = 0;f.pc = nullptr;cout << "Leaving move operator=()\n";return *this;
}

main.cpp

/*
Project name :			_36move_semantics
Last modified Date:		2022年5月23日21点48分
Last Version:			V1.0
Descriptions:			移动构造函数
*/
#include <iostream>
#include "useless.h"
using namespace std;int main()
{cout << "one*******************" << endl;Useless one(10, 'x');cout << "two*******************" << endl;Useless two;two = one; // calls copy constructorcout << "three*******************" << endl;Useless three(20, 'o');cout << "four*******************" << endl;Useless four(one + three); // calls operator+(), move constructorcout << "five*******************" << endl;Useless five; five = one + four;// calls operator+(), move constructor//默认构造，+运算符，移动构造，移动赋值cout << "six*******************" << endl;Useless six;six = std::move(one); // forced move assignment//默认构造函数，移动赋值cout << "object one: ";one.ShowData();cout << "object two: ";two.ShowData();cout << "object three: ";three.ShowData();cout << "object four: ";four.ShowData();cout << "object five: ";five.ShowData();cout << "object six: ";six.ShowData();return 0;
}

运行结果

one*******************
int, char constructor called; number of objects: 1
Number of elements: 10 Data address: 0000022953D00CE0
two*******************
default constructor called; number of objects: 2
Number of elements: 0 Data address: 0000000000000000
Entering operator=()
Leaving operator=()
three*******************
int, char constructor called; number of objects: 3
Number of elements: 20 Data address: 0000022953D011E0
four*******************
Entering operator+()
int constructor called; number of objects: 4
Number of elements: 30 Data address: 0000022953CFC650
temp object:
Leaving operator+()
move constructor called; number of objects: 5
Number of elements: 30 Data address: 0000022953CFC650
destructor called; objects left: 4
deleted object:
Number of elements: 0 Data address: 0000000000000000
five*******************
default constructor called; number of objects: 5
Number of elements: 0 Data address: 0000000000000000
Entering operator+()
int constructor called; number of objects: 6
Number of elements: 40 Data address: 0000022953CFDCA0
temp object:
Leaving operator+()
move constructor called; number of objects: 7
Number of elements: 40 Data address: 0000022953CFDCA0
destructor called; objects left: 6
deleted object:
Number of elements: 0 Data address: 0000000000000000
Entering move operator=()
Leaving move operator=()
destructor called; objects left: 5
deleted object:
Number of elements: 0 Data address: 0000000000000000
six*******************
default constructor called; number of objects: 6
Number of elements: 0 Data address: 0000000000000000
Entering move operator=()
Leaving move operator=()
object one: (object empty)
object two: xxxxxxxxxx
object three: oooooooooooooooooooo
object four: xxxxxxxxxxoooooooooooooooooooo
object five: xxxxxxxxxxxxxxxxxxxxoooooooooooooooooooo
object six: xxxxxxxxxx
destructor called; objects left: 5
deleted object:
Number of elements: 10 Data address: 0000022953D00CE0
destructor called; objects left: 4
deleted object:
Number of elements: 40 Data address: 0000022953CFDCA0
destructor called; objects left: 3
deleted object:
Number of elements: 30 Data address: 0000022953CFC650
destructor called; objects left: 2
deleted object:
Number of elements: 20 Data address: 0000022953D011E0
destructor called; objects left: 1
deleted object:
Number of elements: 10 Data address: 0000022953D015A0
destructor called; objects left: 0
deleted object:
Number of elements: 0 Data address: 0000000000000000D:\Prj\_C++Self\_36move_semantics\x64\Debug\_36move_semantics.exe (进程 4060)已退出，代码为 0。
要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
按任意键关闭此窗口. . .

11.3.7 default关键字

关键字default显式地声明方法为默认版本。

default关键字只能用于6个特殊成员函数(默认构造函数、复制构造函数、复制赋值运算符、析构函数、移动构造函数、移动赋值运算符)。

class Someclass
{
public:Someclass(Someclass &&);Someclass() = default; // use compiler-generated default constructorSomeclass(const Someclass &) = default;Someclass & operator=(const Someclass &) = default;...
};

11.3.8 delete关键字

关键字delete用于禁止编译器使用特定方法。例如，要禁止复制对象，可禁用复制构造函数和复制赋值运算符。

delete关键字可用于任何成员函数。

class Someclass
{
public:Someclass() = default; // use compiler-generated default constructor// disable copy constructor and copy assignment operator:Someclass(const Someclass&) = delete;Someclass& operator=(const Someclass&) = delete;// use compiler-generated move constructor and move assignment operator:Someclass(Someclass&&) = default;Someclass& operator=(Someclass&&) = default;Someclass& operator+(const Someclass&) const;...
};

要禁止复制，可以将复制构造函数和赋值运算符放在类定义的private部分，但使用delete也能达到这个目的，且更不容易犯错，更容易理解。
如果在启用移动方法同时禁用复制方法，那么将允许移动复制而不允许按值复制。

Someclass one;
Someclass two;
Someclass three(one); // not allowed, one an lvalue
Someclass four(one + two); // allowed, expression is an rvalue

delete的一种应用场景为：禁止特定的转换。

class Someclass
{
public:...void redo(double);...
};
Someclass sc;
sc.redo(5);//OKclass Someclass
{
public:...void redo(double);void redo(int) = delete;...
};Someclass sc;
sc.redo(5);//error---编译错误

11.3.9 委托构造函数

在一个构造函数的定义中使用另一个构造函数，被称为委托。

class Notes {int k;double x;std::string st;
public:Notes();Notes(int);Notes(int, double);Notes(int, double, std::string);
};
Notes::Notes(int kk, double xx, std::string stt) : k(kk),
x(xx), st(stt) {/*do stuff*/
}
Notes::Notes() : Notes(0, 0.01, "Oh") {/* do other stuff*/ }
Notes::Notes(int kk) : Notes(kk, 0.01, "Ah") {/* do yet other stuff*/ }
Notes::Notes(int kk, double xx) : Notes(kk, xx, "Uh") {/* ditto*/ }

默认构造函数使用第一个构造函数初始化数据成员并执行函数体，然后再执行自己的函数体。

11.3.10 继承构造函数

让派生类能够继承基类构造函数的机制。让派生类继承基类所有的构造函数，但是派生类自己定义的构造函数将覆盖与之参数相同的基类的构造函数。

class BS
{int q;double w;
public:BS() : q(0), w(0) {}BS(int k) : q(k), w(100) {}BS(double x) : q(-1), w(x) {}B0(int k, double x) : q(k), w(x) {}void Show() const { std::cout << q << ", " << w << '\n'; }
};
class DR : public BS
{short j;
public:using BS::BS;DR() : j(-100) {} // DR needs its own default constructorDR(double x) : BS(2 * x), j(int(x)) {}DR(int i) : j(-2), BS(i, 0.5 * i) {}void Show() const { std::cout << j << ", "; BS::Show(); }
};
int main()
{DR o1; // use DR()DR o2(18.81); // use DR(double) instead of BS(double)DR o3(10, 1.8); // use BS(int, double)...
}

11.3.11 const成员函数

const Stock land = Stock("Kludgehorn Properties");
land.show();

对于当前C++来说，编译器将拒绝第二行，这是为什么呢？因为show()的代码无法确保调用对象不被修改—调用对象和const一样，不应被修改。C++的解决方法是将const关键字放在函数的括号后面，使之成为const成员函数。

void show() const; // promises not to change invoking object
void stock::show() const // promises not to change invoking object

http://chatgpt.dhexx.cn/article/BnWYsR0L.shtml

相关文章

C++ 构造函数和析构函数可以是虚函数嘛？

C++ 构造函数和析构函数可以是虚函数嘛？

简单总结就是&#xff1a;构造函数不可以是虚函数&#xff0c;而析构函数可以且常常是虚函数。 构造函数不能是虚函数 1. 从vptr角度解释 虚函数的调用是通过虚函数表来查找的&#xff0c;而虚函数表由类的实例化对象的vptr指针(vptr可以参考C的虚函数表指针vptr)指向&#x…
阅读更多...
构造函数和析构函数顺序

构造函数和析构函数顺序

父子类 1、构造顺序&#xff1a; 创建一个子类对象&#xff0c;则父类、子类的构造方法都执行&#xff0c;且是 先父类 构造方法&#xff0c;再子类构造方法 派生类的构造顺序&#xff1a;先父类&#xff0c;后子类&#xff0c;因为子类很有可能会用到从父类继承来的成员 2、析…
阅读更多...
【C++】构造函数与析构函数

【C++】构造函数与析构函数

1. 概述 构造函数&#xff1a;用于初始化对象&#xff0c;没有返回值&#xff0c;函数名和类名相同&#xff0c;只有在对象初始化的时候才会被调用。构造函数的分类&#xff1a; 默认构造函数&#xff1a;是编译器自动生成&#xff0c;没有任何参数的构造函数。 有参构造函数&…
阅读更多...
何时调用构造函数和析构函数

何时调用构造函数和析构函数

何时调用构造函数和析构函数 构造函数的作用是保证每个对象的数据成员都有何时的初始值。 析构函数的作用是回收内存和资源&#xff0c;通常用于释放在构造函数或对象生命期内获取的资源。 一般我们都知道构造和析构的次序&#xff1a; 构造从类层次的最根处开始&#xff0c…
阅读更多...
C++篇----构造函数和析构函数

C++篇----构造函数和析构函数

在很多时候&#xff0c;当写了初始化&#xff0c;动态开辟的&#xff0c;需要写销毁函数&#xff0c;写了销毁函数之后&#xff0c;但是却忘记了调用这些函数&#xff0c;忘记调用初始化函数还好&#xff0c;编译器会报错&#xff0c;但是如果是忘记调用销毁函数&#xff0c;那…
阅读更多...
c++构造函数和析构函数

c++构造函数和析构函数

一、构造函数和析构函数的特点 构造函数和析构函数是一种特殊的公有成员函数&#xff0c;每一个类都有一个默认的构造函数和析构函数&#xff1b;构造函数在类定义时由系统自动调用&#xff0c;析构函数在类被销毁时由系统自动调用&#xff1b;构造函数的名称和类名相同&#…
阅读更多...
构造函数与析构函数

构造函数与析构函数

一&#xff0c;引言 由于c语言常常会忘记初始化与销毁&#xff0c;造成许多麻烦。所以c就引入了构造函数与析构函数&#xff0c;分别用来完成初始化与清理工作&#xff0c;且由编译器自动调用&#xff0c;这就避免了许多麻烦。 二&#xff0c;构造函数 构造函数是一个特殊的成…
阅读更多...
构造函数和析构函数

构造函数和析构函数

文章目录 前言 1.构造函数<1>概念<2>特性 2.初始化列表<1>概念<2>特征 3.析构函数<1>概念<2.>特征 前言 如不清楚类的定义可以点击此篇文章&#xff1a;类的定义与引入 C为很么要引入构造函数和析构函数呢&#xff0c;前文讲到大佬引入了…
阅读更多...
C++ 构造函数和析构函数 详解

C++ 构造函数和析构函数 详解

目录 概述构造函数的分类1. 无参(默认)构造函数2. 有参构造函数3. 委托构造函数4. 复制(拷贝)构造函数5. 移动构造函数 构造函数调用规则析构函数 概述 C中用构造函数和析构函数来初始化和清理对象&#xff0c;这两个函数将会被编译器自动调用。对象的初始化和清理是非常重要的…
阅读更多...
java异常处理及自定义异常

java异常处理及自定义异常

异常处理的实际上就是&#xff1a; 有风险的行为&#xff08;方法&#xff09;可能会将异常抛出&#xff08;throws&#xff09;。调用该方法的程序会尝试&#xff08;try&#xff09;去运行,运行的同时捕捉&#xff08;catch&#xff09;异常。 简而言之&#xff0c;就是对有…
阅读更多...
java异常 — — 自定义异常

java异常 — — 自定义异常

三、自定义异常 3.1、概述 为什么需要自定义异常类: Java中不同的异常类分别表示看某一种具体的异常情况&#xff0c;那么在开发中总是有些异常情况是SUN没有定义好的此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题&#xff0c;考试成绩负数问题等等。 在上…
阅读更多...
JAVA自定义异常处理

JAVA自定义异常处理

自定义异常处理可以分为两种&#xff0c;一种是自定义编译处理&#xff0c;另一种是自定义运行处理 1.自定义编译处理需要创建一个异常类用于继承Exception类 重写构造器 在出现异常的地方用throw new 自定义对象抛出 作用&#xff1a;编译时异常时编译阶段就报错&#xff…
阅读更多...
Java的自定义异常类

Java的自定义异常类

Java的异常处理机制可以让程序具有极好的容错性&#xff0c;让程序更加健壮。当程序运行出 现意外情形时&#xff0c;系统会自动生成一个 Exception对象来通知程序&#xff0c;从而实现将“业务功 能实现代码”和“错误处理代码”分离&#xff0c;提供更好的可读性。 Java把所…
阅读更多...
Java自定义异常及统一处理，信息返回

Java自定义异常及统一处理，信息返回

开始操作 创建enums&#xff0c;exception包&#xff1a; enums包下&#xff1a; 创建BaseCodeEnum接口 创建Response类&#xff1a;为统一信息返回类 创建ResponseCode枚举类&#xff1a;在这里定义我们需要的异常 exception包下&#xff1a; 创建HandlerException类&#…
阅读更多...
Java自定义异常类统一处理异常

Java自定义异常类统一处理异常

当程序发生异常时&#xff0c;会返回一大堆不友好的内容&#xff0c;非常不美观&#xff01; 我们在写代码的时候&#xff0c;对异常处理一般是try catch或者抛出异常throws Exception。 try catch大家都知道&#xff0c;代码中大量的try catch会占用内存影响性能&#xff0c…
阅读更多...
Java中的自定义异常

Java中的自定义异常

代码实现 自定义异常类型主要实现代码 public class Exception_demo extends Exception{//自定义异常&#xff0c;需要把自定义异常类继承于Exception异常类&#xff0c;自定义异常类属于异常类的子类public Exception_demo(){//构造方法也叫做构造器&#xff0c;构造方法的名…
阅读更多...
【Java异常】自定义异常

【Java异常】自定义异常

Java中定义了大量的异常类&#xff0c;虽然这些异常类可以描述编程时出现的大部分异常情况&#xff0c;但是在程序开发中有时可能需要描述程序中特有的异常情况,例如在设计divide()方法时不允许被除数为负数。为了解决这样的问题,Java允许用户自定义异常&#xff0c;但自定义的…
阅读更多...
JAVA项目中自定义异常

JAVA项目中自定义异常

JAVA项目中自定义异常 1.数据返回处理类 Data public class R<T> implements Serializable {private static final long serialVersionUID -8497670085742879369L;ApiModelProperty(value "返回码", example "200")private Integer code200;Api…
阅读更多...
Java自定义异常理解

Java自定义异常理解

前言&#xff1a;看了许多博客和书&#xff0c;都对自定异常一笔带过&#xff0c;总让人感觉莫名奇妙&#xff0c;一直在问自己一个问题&#xff0c;我们能很好的解决异常就很不错了&#xff0c;为什么还要自己自定义异常&#xff0c;让自己去自找麻烦呢&#xff1f;后来我才理…
阅读更多...
Java自定义异常

Java自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外&#xff0c;用户还可以自定义异常。用户自定义异常类&#xff0c;只需继承Excepition类即可 在程序当中自定义异常类&#xff0c;大体可以分成几个步骤&#xff1a; 1.创建自定义异常类 2.在方法中通过t…
阅读更多...
推荐文章

Copyright @ 2022~2023