#include <bits/stdc++.h>
using namespace std;

class Student {
	private:
		int id;
		string name;
		double score;
	public:
		Student(int d, string ame, double core): id(d), name(ame) //不同的方式。
		{
			score = core;
		}
		void print() {
			cout << "学号：" << id << endl;
			cout << "姓名：" << name << endl;
			cout << "分数：" << score << endl;
		}
};

int main () {
	Student s(2021, "FH", 90);
	s.print();
	return 0;
}
 
常规点
 
#include <bits/stdc++.h>
using namespace std;

class Student {
	private:
		int id;
		string name;
		double score;
	public:
		Student(int d, string ame, double core)
		{
			id=d;
			name = ame;
			score = core;
		}
		void print() {
			cout << "学号：" << id << endl;
			cout << "姓名：" << name << endl;
			cout << "分数：" << score << endl;
		}
};

int main () {
	Student s(2021, "FH", 90);
	s.print();
	return 0;
}
 
如果不是拷贝构造函数好像会出错。

 
问题
 
默认构造函数与直接初始化对象字段之间的区别是什么？
 
有什么理由更喜欢以下示例中的一个而不是另一个？
 
###例1
 
public class Foo
 
{
 
private int x = 5;
 
private String[] y = new String[10];
 
}
 
###例2
 
public class Foo
 
{
 
private int x;
 
private String[] y;
 
public Foo()
 
{
 
x = 5;
 
y = new String[10];
 
}
 
}
 
#1 热门回答(55 赞)
 
初始化器在构造函数体之前执行。 (如果你同时具有初始化器和构造函数，则构造函数执行第二个并覆盖初始化值，这会产生影响)
 
当你总是需要相同的初始值时(例如，在你的示例中，给定大小的数组或特定值的整数)，初始化器很好，但它可以对你有利或对你有利：
 
如果你有许多构造函数以不同的方式初始化变量(即具有不同的值)，那么初始化程序是无用的，因为更改将被覆盖并且浪费。
 
另一方面，如果你有许多构造函数初始化具有相同的值，那么你可以通过在一个地方保持初始化来保存代码行(并使代码稍微更易于维护)。
 
就像迈克尔所说的那样，也有一些品味问题 - 你可能希望将代码放在一个地方。虽然如果你有很多构造函数，你的代码在任何情况下都不在一个地方，所以我倾向于初始化者。
 
#2 热门回答(18 赞)
 
更喜欢第一个例子的原因是它对于更少的代码(总是好的)具有相同的功能。
 
除此之外，没有区别。
 
但是，如果你有明确的构造函数，我宁愿将所有初始化代码放入那些(并链接它们)，而不是在构造函数和字段初始化程序之间拆分它们。
 
#3 热门回答(4 赞)
 
我们是否应该使用字段初始值设定项或构造函数为字段提供默认值？
 
我不会考虑在字段实例化和字段延迟/渴望实例化期间可能出现的异常，这些异常会触及除可读性和可维护性问题之外的其他问题。
 
对于执行相同逻辑并产生相同结果的两个代码，应该优先考虑具有最佳可读性和可维护性的方法。
 
TL; DR
 
选择第一个或第二个选项是在所有代码组织，可读性和可维护性问题之前。
 
保持选择的一致性(使整个应用程序代码更清晰)
 
不要犹豫，使用字段初始值设定项来实例化Collection字段以防止NullPointerException
 
不要对可能被构造函数覆盖的字段使用字段初始值设定项
 
在具有单个构造函数的类中，字段初始化方法通常更具可读性且更简洁
 
在具有多个构造函数的类中，构造函数之间没有或很少有耦合，字段初始化方式通常更具可读性和更简洁
 
在具有多个构造函数的类中，构造函数在它们之间具有耦合，这两种方式中没有一个真的更好，但无论选择哪种方式，将它与链接构造函数组合就是方法(参见用例1)。
 
OP问题
 
使用非常简单的代码，字段声明期间的分配似乎更好，而且确实如此。
 
这更简洁，更直接：
 
public class Foo {
 
private int x = 5;
 
private String[] y = new String[10];
 
}
 
比构造函数的方式：
 
public class Foo{
 
private int x;
 
private String[] y;
 
public Foo(){
 
x = 5;
 
y = new String[10];
 
}
 
}
 
在具有如此真实特征的真实课堂中，事物是不同的。
 
事实上，根据遇到的具体情况，一种方式，另一方或任何一方应该受到青睐。
 
##更详细的例子来说明
 
研究案例1
 
我将从一个简单的Car类开始，我将更新以说明这些要点。
 
Cardeclare 4个字段和一些在它们之间有关系的构造函数。
 
1.在所有字段的字段初始值设定项中提供默认值是不可取的
 
public class Car {
 
private String name = "Super car";
 
private String origin = "Mars";
 
private int nbSeat = 5;
 
private Color color = Color.black;
 
...
 
...
 
// Other fields
 
...
 
public Car() {
 
}
 
public Car(int nbSeat) {
 
this.nbSeat = nbSeat;
 
}
 
public Car(int nbSeat, Color color) {
 
this.nbSeat = nbSeat;
 
this.color = color;
 
}
 
}
 
字段声明中指定的默认值并非都是可靠的。只有name和origin字段具有真正的默认值。
 
nbSeat和colorfields首先在它们的声明中被赋值，然后这些可能会在带有参数的构造函数中被覆盖。
 
它容易出错，除了这种评估字段的方式外，该类还降低了其可靠性水平。如果在两个字段中证明不可靠，那么如何依赖字段声明期间分配的任何默认值？
 
2.使用构造函数来估计所有字段并依赖构造函数链接很好
 
public class Car {
 
private String name;
 
private String origin;
 
private int nbSeat;
 
private Color color;
 
...
 
...
 
// Other fields
 
...
 
public Car() {
 
this(5, Color.black);
 
}
 
public Car(int nbSeat) {
 
this(nbSeat, Color.black);
 
}
 
public Car(int nbSeat, Color color) {
 
this.name = "Super car";
 
this.origin = "Mars";
 
this.nbSeat = nbSeat;
 
this.color = color;
 
}
 
}
 
这个解决方案非常好，因为它不会创建重复，它会收集一个地方的所有逻辑：具有最大参数数量的构造函数。
 
它有一个缺点：需要将调用链接到另一个构造函数。
 
但这是一个缺点吗？
 
3.在字段初始化器中为构造函数未分配给它们的字段提供默认值新值更好但仍有重复问题
 
通过在声明中不重视nbSeat和colorfields，我们清楚地区分具有默认值的字段和没有的字段。
 
public class Car {
 
private String name = "Super car";
 
private String origin = "Mars";
 
private int nbSeat;
 
private Color color;
 
...
 
...
 
// Other fields
 
...
 
public Car() {
 
nbSeat = 5;
 
color = Color.black;
 
}
 
public Car(int nbSeat) {
 
this.nbSeat = nbSeat;
 
color = Color.black;
 
}
 
public Car(int nbSeat, Color color) {
 
this.nbSeat = nbSeat;
 
this.color = color;
 
}
 
}
 
这个解决方案相当不错但它重复了每个Car构造函数中的实例化逻辑，这与之前的构造函数链接解决方案相反。
 
在这个简单的例子中，我们可以开始理解重复问题，但似乎只是有点烦人。
 
在实际情况中，复制可能非常重要，因为构造函数可以执行计算和验证。
 
让单个构造函数执行实例化逻辑变得非常有帮助。
 
所以最后在fields声明中的赋值并不总是使构造函数无法委托给另一个构造函数。
 
这是一个改进版本。
 
4.在字段初始化器中为构造函数不为其分配新值并依赖构造函数链接的字段提供默认值
 
public class Car {
 
private String name = "Super car";
 
private String origin = "Mars";
 
private int nbSeat;
 
private Color color;
 
...
 
...
 
// Other fields
 
...
 
public Car() {
 
this(5, Color.black);
 
}
 
public Car(int nbSeat) {
 
this(nbSeat, Color.black);
 
}
 
public Car(int nbSeat, Color color) {
 
// assignment at a single place
 
this.nbSeat = nbSeat;
 
this.color = color;
 
// validation rules at a single place
 
...
 
}
 
}
 
研究案例2
 
我们将修改原始的Car类。
 
现在，Cardeclare 5个字段和3个构造函数，它们之间没有关系。
 
1.使用构造函数对具有默认值的字段赋值是不合需要的
 
public class Car {
 
private String name;
 
private String origin;
 
private int nbSeat;
 
private Color color;
 
private Car replacingCar;
 
...
 
...
 
// Other fields
 
...
 
public Car() {
 
initDefaultValues();
 
}
 
public Car(int nbSeat, Color color) {
 
initDefaultValues();
 
this.nbSeat = nbSeat;
 
this.color = color;
 
}
 
public Car(Car replacingCar) {
 
initDefaultValues();
 
this.replacingCar = replacingCar;
 
// specific validation rules
 
}
 
private void initDefaultValues() {
 
name = "Super car";
 
origin = "Mars";
 
}
 
}
 
由于我们在声明中没有重视name和origin字段，并且我们没有其他构造函数自然调用的公共构造函数，因此我们不得不引入ainitDefaultValues()方法并在每个构造函数中调用它。所以我们不要忘记称这种方法。
 
请注意，我们可以在no arg构造函数中使用inlineinitDefaultValues()，但是从其他构造函数调用没有arg的this()并不是必然的，可能很容易被遗忘：
 
public class Car {
 
private String name;
 
private String origin;
 
private int nbSeat;
 
private Color color;
 
private Car replacingCar;
 
...
 
...
 
// Other fields
 
...
 
public Car() {
 
name = "Super car";
 
origin = "Mars";
 
}
 
public Car(int nbSeat, Color color) {
 
this();
 
this.nbSeat = nbSeat;
 
this.color = color;
 
}
 
public Car(Car replacingCar) {
 
this();
 
this.replacingCar = replacingCar;
 
// specific validation rules
 
}
 
}
 
2.在字段初始值设定项中为构造函数未分配给它们的字段提供默认值罚款
 
public class Car {
 
private String name = "Super car";
 
private String origin = "Mars";
 
private int nbSeat;
 
private Color color;
 
private Car replacingCar;
 
...
 
...
 
// Other fields
 
...
 
public Car() {
 
}
 
public Car(int nbSeat, Color color) {
 
this.nbSeat = nbSeat;
 
this.color = color;
 
}
 
public Car(Car replacingCar) {
 
this.replacingCar = replacingCar;
 
// specific validation rules
 
}
 
}
 
在这里，我们不需要调用ainitDefaultValues()方法或无arg构造函数。现场初始化器是完美的。
 
结论
 
**在任何情况下)**不应对所有字段执行字段初始值设定项中的值字段，而只应对那些无法被构造函数覆盖的字段执行。
 
**用例1)**如果多个构造函数之间有共同处理，则主要基于意见。
 
解决方案2(使用构造函数对所有字段进行值，并依赖构造函数链接)和解决方案4(在字段初始化器中为构造函数不为其分配新值并依赖于构造函数链接的字段中的默认值)作为最易读，可维护和强大的解决方案。
 
**用例2)**如果多个构造函数之间没有共同的处理/关系，如在单个构造函数的情况下，解决方案2(在字段初始化器中为构造函数不为其分配新值的字段提供默认值)看起来更好。

 
复制构造函数是构造函数的一种，也称拷贝构造函数，它只有一个参数，参数类型是本类的引用。
 
复制构造函数的参数可以是 const 引用，也可以是非 const 引用。 一般使用前者，这样既能以常量对象(初始化后值不能改变的对象)作为参数，也能以非常量对象作为参数去初始化其他对象。一个类中写两个复制构造函数，一个的参数是 const 引用，另一个的参数是非 const 引用，也是可以的。
 
如果类的设计者不写复制构造函数，编译器就会自动生成复制构造函数。大多数情况下，其作用是实现从源对象到目标对象逐个字节的复制，即使得目标对象的每个成员变量都变得和源对象相等。编译器自动生成的复制构造函数称为“默认复制构造函数”。
 
注意，默认构造函数(即无参构造函数)不一定存在，但是复制构造函数总是会存在。
 
下面是一个复制构造函数的例子。
 
#include
 
using namespace std;
 
class Complex
 
{
 
public:
 
double real, imag;
 
Complex(double r, double i) {
 
real= r; imag = i;
 
}
 
};
 
int main(){
 
Complex cl(1, 2);
 
Complex c2 (cl); //用复制构造函数初始化c2
 
cout<
 
return 0;
 
}
 
第 13 行给出了初始化 c2 的参数，即 c1。只有编译器自动生成的那个默认复制构造函数的参数才能和 c1 匹配，因此，c2 就是以 c1 为参数，调用默认复制构造函数进行初始化的。初始化的结果是 c2 成为 c1 的复制品，即 c2 和 c1 每个成员变量的值都相等。
 
如果编写了复制构造函数，则默认复制构造函数就不存在了。下面是一个非默认复制构造函数的例子。
 
#include
 
using namespace std;
 
class Complex{
 
public:
 
double real, imag;
 
Complex(double r,double i){
 
real = r; imag = i;
 
}
 
Complex(const Complex & c){
 
real = c.real; imag = c.imag;
 
cout<
 
}
 
};
 
int main(){
 
Complex cl(1, 2);
 
Complex c2 (cl); //调用复制构造函数
 
cout<
 
return 0;
 
}
 
程序的输出结果是：
 
Copy Constructor called
 
1,2
 
第 9 行，复制构造函数的参数加不加 const 对本程序來说都一样。但加上 const 是更好的做法，这样复制构造函数才能接受常量对象作为参数，即才能以常量对象作为参数去初始化别的对象。
 
第 17 行，就是以 c1 为参数调用第 9 行的那个复制构造函数初始化的。该复制构造函数执行的结果是使 c2 和 c1 相等，此外还输出Copy Constructor called。
 
可以想象，如果将第 10 行删去或改成real = 2*c.real; imag = imag + 1;，那么 c2 的值就不会等于 c1 了。也就是说，自己编写的复制构造函数并不一定要做复制的工作(如果只做复制工作，那么使用编译器自动生成的默认复制构造函数就行了)。但从习惯上来讲，复制构造函数还是应该完成类似于复制的工作为好，在此基础上还可以根据需要做些別的操作。
 
构造函数不能以本类的对象作为唯一参数，以免和复制构造函数相混淆。例如，不能写如下构造函数：
 
Complex (Complex c) {...}
 
复制构造函数被调用的三种情况
 
复制构造函数在以下三种情况下会被调用。
 
1) 当用一个对象去初始化同类的另一个对象时，会引发复制构造函数被调用。例如，下面的两条语句都会引发复制构造函数的调用，用以初始化 c2。
 
Complex c2(c1);
 
Complex c2 = c1;
 
这两条语句是等价的。
 
注意，第二条语句是初始化语句，不是赋值语句。赋值语句的等号左边是一个早已有定义的变量，赋值语句不会引发复制构造函数的调用。例如：
 
Complex c1, c2; c1 = c2 ;
 
c1=c2;
 
这条语句不会引发复制构造函数的调用，因为 c1 早已生成，已经初始化过了。
 
2) 如果函数 F 的参数是类 A 的对象，那么当 F 被调用时，类 A 的复制构造函数将被调用。换句话说，作为形参的对象，是用复制构造函数初始化的，而且调用复制构造函数时的参数，就是调用函数时所给的实参。
 
#include
 
using namespace std;
 
class A{
 
public:
 
A(){};
 
A(A & a){
 
cout<
 
}
 
};
 
void Func(A a){ }
 
int main(){
 
A a;
 
Func(a);
 
return 0;
 
}
 
程序的输出结果为：
 
Copy constructor called
 
这是因为 Func 函数的形参 a 在初始化时调用了复制构造函数。
 
前面说过，函数的形参的值等于函数调用时对应的实参，现在可以知道这不一定是正确的。如果形参是一个对象，那么形参的值是否等于实参，取决于该对象所属的类的复制构造函数是如何实现的。例如上面的例子，Func 函数的形参 a 的值在进入函数时是随机的，未必等于实参，因为复制构造函数没有做复制的工作。
 
以对象作为函数的形参，在函数被调用时，生成的形参要用复制构造函数初始化，这会带来时间上的开销。如果用对象的引用而不是对象作为形参，就没有这个问题了。但是以引用作为形参有一定的风险，因为这种情况下如果形参的值发生改变，实参的值也会跟着改变。
 
如果要确保实参的值不会改变，又希望避免复制构造函数带来的开销，解决办法就是将形参声明为对象的 const 引用。例如：
 
void Function(const Complex & c)
 
{
 
...
 
}
 
这样，Function 函数中出现任何有可能导致 c 的值被修改的语句，都会引发编译错误。
 
思考题：在上面的 Function 函数中，除了赋值语句，还有什么语句有可能改变 c 的值？例如，是否允许通过 c 调用 Complex 的成员函数？
 
3) 如果函数的返冋值是类 A 的对象，则函数返冋时，类 A 的复制构造函数被调用。换言之，作为函数返回值的对象是用复制构造函数初始化 的，而调用复制构造函数时的实参，就是 return 语句所返回的对象。例如下面的程序：
 
#include
 
using namespace std;
 
class A {
 
public:
 
int v;
 
A(int n) { v = n; };
 
A(const A & a) {
 
v = a.v;
 
cout << "Copy constructor called" << endl;
 
}
 
};
 
A Func() {
 
A a(4);
 
return a;
 
}
 
int main() {
 
cout << Func().v << endl;
 
return 0;
 
}
 
程序的输出结果是：
 
Copy constructor called
 
4
 
第19行调用了 Func 函数，其返回值是一个对象，该对象就是用复制构造函数初始化的， 而且调用复制构造函数时，实参就是第 16 行 return 语句所返回的 a。复制构造函数在第 9 行确实完成了复制的工作，所以第 19 行 Func 函数的返回值和第 14 行的 a 相等。
 
需要说明的是，有些编译器出于程序执行效率的考虑，编译的时候进行了优化，函数返回值对象就不用复制构造函数初始化了，这并不符合 C++ 的标准。上面的程序，用 Visual Studio 2010 编译后的输出结果如上所述，但是在 Dev C++ 4.9 中不会调用复制构造函数。把第 14 行的 a 变成全局变量，才会调用复制构造函数。对这一点，读者不必深究。

一、构造函数
 
是为了让我们自己去规定 ， 我们定义对象的初始化。
 这里给出一段程序，作用是按格式输出 输入的时间。
 
#include <iostream>
using std::cin;
using std::cout;
using std::endl;
class Clock{ 
    public:
    	void setTime(int newS = 0, int newM = 0, int newH = 0){
    	//这一步如果想要输出默认值，应该把主函数里的setTime函数中的参数删除。
            second = newS;
            minute = newM;
            hour = newH; 
        }
    	void showTime();
    private:
        int second, minute, hour;
};
void Clock::showTime(){
   cout << hour << ":" << minute << ":" << second <<endl;
}
int main(){
    Clock MyClock;
    int second, minute, hour;
    cin >> second >> minute >> hour;
    MyClock.setTime(second, minute, hour);
    MyClock.showTime();
    return 0;
}
 
构造函数的性质：
 ● 不能定义返回值类型，也不能写return语句
 ●可以有形参，也可以没有形参，可以带有默认参数
 ●函数名必须和类名完全相同
 ●可以重载
 
当我们没有写构造函数时，系统会为我们自动生成一个默认构造函数，这个默认构造函数的参数列表和内容都是空的，所以他什么都不会做！
 
现在 我们需要创建一个默认构造函数，让对象早初始化的时候把所有的时间全部设置为0。
 
//在类内定义构造函数时，不能有返回值类型，且构造函数的名字要和类一样，可以有形参也可以没有形参，这里的第一种定义是没有形参的类型：
class Clock{
public:
    Clock(){
        second = 0;
        minute = 0;
        hour = 0;
    }
//如果不写构造函数，那么系统自动生成的构造函数 就是
    Clock(){}
//函数里没有任何内容，所以也不会有操作
 
第二种定义类型是有参数的形式：
 
Class Clock{
public:
	Clock(int newS, int newM, int newH){
    second = newS;
    minute = newM;
    hour = newH;
}
}

//或者在类外实现构造函数
Class Clock{
public:
	Clock(int newS, int newM, int newH);
	}
Clock::Clock(int newS, int newM, int newH){
    second = newS;
    minute = newM;
    hour = newH;
}
这里在类外实现构造函数时，函数名前面仍然不要写函数的返回值类型 ，
实现类外构造函数 ： 在类内对函数定义，然后在类外 用 
 类名 :: 函数名 ( 参数 ) { 函数体 }   的形式在类外实现构造函数。 

而在类外实现普通函数时，也是在类内先对函数进行定义，然后在类外 用
返回值类型 类名 :: 函数名 ( 参数 ) { 函数体 } 实现，这里需要在类
名前面加上返回值类型
 
调用带参数的构造函数时，是在对象创建时被调用的：
 
 Clock MyClock2(1,2,3);
 
二、复制构造函数
 
用一个已有的对象，来执行一个新的对象的构造
 ●复制构造函数具有一般构造函数的所有特性，它的形参是本类的一个对象的引用，作用是用一个已经存在的对象（函数的参数）来初始化一个新的对象。
 ●复制构造函数的的使用方式 就是引用传参。
 
引用就是 给一个已经存在的变量起一个别名，所以用它的变量名或者别名都可以操作该变量, 复制构造函数就是给已经存在的构造函数起一个别名。
 
因为：值传递就是当函数发生调用的时候，给形参分配内存空间，然后用实参的值来初始化形参，但是如果参数是一个对象，值传递“初始化形参”这个过程就会造成很多额外的时间开销，浪费系统资源，如果使用引用就不会有这样的问题。
 
复制构造函数能实现同类对象之间数据成员的传递。 当我们没有定义类的构造韩函数时，系统就会在必要的时候自动生成一个隐含的复制构造函数，他的作用是把初始对象的每一个数据成员的值都复制到新建的对象中，这就完成了同类对象的复制。
 复制构造函数的具体声明方式 ：
 
class 类名{
public:
	类名(类名& 对象名){
	//实现
	}
};
 
实例：
 先有一个point类，表示屏幕上的一个点——它包括两个 int 类的私有成员 x , y, 表示这个点的坐标。
 
class Point {
public:
	Point(Point &p);
private:
	int x,y;
};

//以下代码可实现复制构造函数
Point::Point(Point &p){
	x = p.x;
	y = p.y;
}
//这里复制构造函数访问了Point类的实例对象p的两个私有成员变量 x,y 。我们需要注意的是 ———— private 与 public 的区别是对类来说的，而不是对对象来说。 拷贝构造函数是Point类的成员函数————所以它可以访问类的私有成员变量，这跟具体的对象无关。
 
复制构造函数被调用主要的三种情况：
 ●当用类的一个对象去初始化该类的另一个对象的时候：
 
Point a(1,2);
Point b(a);//用对象a初始化对象b,复制构造函数被调用
Point c = b;//用对象b给对象c赋值，复制构造函数被调用
 
●当函数的形参是类的对象，调用函数是进行形式结合的时候：
 
void f(Point p){
    //函数体
}
int main(){
    Point a(1,2);
    f(a);
    return 0;
}
 
●当函数返回值是类的对象，函数执行完成返回调用者的时候：
 
Point g(){
    Point a(1,2);
    return a;
}
/*定义在函数中的变量都是局部变量，当函数返回值的时候这些局部变量
都被销毁了。同样，在函数中创建的对象也相同。 return a 这一步返
回的并不是 a 这个对象本身，而是通过复制构造函数，在主调函数中用a
重新构造的对象。在函数调用返回的时候，原来的临时对象 a 的使命已
经完成，随着整个函数中的其他临时变量一起被销毁了。*/
 
对于复制构造函数，我们还可以自己实现一些有选择、有变化的复制：
 
Point (point &p){
    x = p.x+10;
    p=p.y;
}
 
这个函数就会把每一个由复制构造得到的Point对象，横坐标+10.