当前位置：首页 > news >正文

建网站自己做服务器/网络平台怎么创建需要多少钱

news 2025/6/30 0:00:43

建网站自己做服务器,网络平台怎么创建需要多少钱,甘肃省专业做网站,国家市场监督管理总局特殊食品安全监督管理司C中默认构造函数就是没有形参的构造函数。准确的说法，按照《C Primer》中定义：只要定义一个对象时没有提供初始化式，就是用默认构造函数。为所有的形参提供默认实参的构造函数也定义了默认构造函数。合成的默认构造函数，即编译…

C++中默认构造函数就是没有形参的构造函数。准确的说法，按照《C++ Primer》中定义：只要定义一个对象时没有提供初始化式，就是用默认构造函数。为所有的形参提供默认实参的构造函数也定义了默认构造函数。

合成的默认构造函数，即编译器自动生成的默认构造函数。《C++ Primer》中的说明：一个类哪怕只定义了一个构造函数，编译器也不会再生成默认构造函数。这条规则的根据是，如果一个类再某种情况下需要控制对象初始化，则该类很可能在所有情况下都需要控制。只有当一个类没有定义构造函数时，编译器才会自动生成一个默认构造函数。

需要注意的是自定义的构造函数包括拷贝构造函数。就是说在下面这种情况下，编译器也不会自动生成默认构造函数，代码会出错。把拷贝构造函数删除掉后就没有问题了。

编译器为类自动生成的函数包括默认构造函数，拷贝构造函数，析构函数，赋值函数。但是如果自己定义了拷贝构造函数，那么默认构造函数编译器就不会自动生成了。但是自己定义了默认构造函数时其他函数都会自动生成。

注意拷贝构造函数的参数类型为const Base &类型。&是必须的很容易理解，需要传递引用才行。至于const参数在g++中不加在编译时会报错，在vs中能通过编译。不过建议还是加上，因为传递的是引用，根据原对象构造新的对象时当然不希望将原对象改变。

#include <iostream>using namespace std;class Base{
public://构造函数//Base(){//	cout<<"default constructor invoke!"<<endl;//}//Base(int d){//	this->data=d;//	cout<<"constructor invoke!"<<endl;//}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<endl;this->data=b.data;}//赋值操作符Base & operator=(const Base &b){cout<<"operator constructor invoke!"<<endl;this->data=b.data;}//7构函数~Base(){cout<<"deconstructor invoke!"<<endl;}
private:int data;};int main(){Base b;return 0;
}

首先使用下面的代码测试，默认构造函数，构造函数，拷贝构造函数，赋值操作符的调用：

#include <iostream>using namespace std;class Base{
public://构造函数Base(){cout<<"default constructor invoke!"<<endl;}Base(int d){this->data=d;cout<<"constructor invoke!"<<endl;}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<endl;this->data=b.data;}//赋值操作符void  operator=(const Base &b){cout<<"operator constructor invoke!"<<endl;this->data=b.data;}//析构函数~Base(){cout<<"deconstructor invoke!"<<endl;}private:int data;};int main(){Base b(1);//构造函数调用Base b2=b;//拷贝构造函数调用Base b3;//默认构造函数调用b3=b;//赋值操作符调用return 0;
}

执行结果如下：

在g++和vs中执行的结果都是一样的。

然后添加一个函数调用来测试：

#include <iostream>using namespace std;class Base{public://构造函数Base(){cout<<"default constructor invoke!"<<endl;}Base(int d){this->data=d;cout<<"constructor invoke!"<<endl;}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<endl;this->data=b.data;}//赋值操作符void  operator=(const Base &b){cout<<"operator constructor invoke!"<<endl;this->data=b.data;}//7构函数~Base(){cout<<"deconstructor invoke!"<<endl;}Base play(Base b){return b;}private:int data;};int main(){Base b(1);//构造函数调用Base b2=b;//拷贝构造函数调用Base b3;//默认构造函数调用b3=b;//赋值操作符调用b.play(2);//构造函数调用，拷贝构造函数调用（由于函数返回引起的）return 0;
}

结果如下：函数b.play(2)执行时，首先会使用构造函数（即接受一个int型变量的构造函数）进行隐式的类型转换，即调用一次构造函数。注意,如果play的形参是B&类型的话，就不可以这样做。否则会出错。

然后使用直接调用时：

#include <iostream>using namespace std;class Base{public://构造函数Base(){cout<<"default constructor invoke!"<<endl;}Base(int d){this->data=d;cout<<"constructor invoke!"<<endl;}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<endl;this->data=b.data;}//赋值操作符void  operator=(const Base &b){cout<<"operator constructor invoke!"<<endl;this->data=b.data;}//7构函数~Base(){cout<<"deconstructor invoke!"<<endl;}Base play(Base  b){return b;}private:int data;};int main(){Base b(1);//构造函数调用Base b2=b;//拷贝构造函数调用Base b3;//默认构造函数调用b3=b;//赋值操作符调用b.play(2);//构造函数调用，拷贝构造函数调用（由于函数返回引起的）b.play(b);//<span style="font-size: 11.8181819915771px; font-family: Arial, Helvetica, sans-serif;">第一次拷贝构造函数调用是构造形参，第二次拷贝构造函数调用是函数返回值</span>return 0;
}

输出结构如下：

最开始也不明白为什么是两次拷贝构造函数调用。那么打印出每个对象的地址吧。

vs中的结果：

g++中的结果，可以发现g++中的结果参数进栈的顺序还是有规律的，但是vs好像就没有规律了。

这样还是看不明白，但是和下面代码的这种情况进行比较就比较容易理解了：

#include <iostream>using namespace std;class Base{
public://构造函数Base(){cout<<"default constructor invoke!"<<(int *)this<<endl;}Base(int d){this->data=d;cout<<"constructor invoke!"<<(int *)this<<endl;}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//赋值操作符void  operator=(const Base &b){cout<<"operator constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//7构函数~Base(){cout<<"deconstructor invoke!"<<(int *)this<<endl;}Base play(Base  b){return b;}
private:int data;};int main(){Base b(1);//构造函数调用Base b2=b;//拷贝构造函数调用Base b3;//默认构造函数调用b3=b;//赋值操作符调用b.play(2);//构造函数调用，拷贝构造函数调用（由于函数返回引起的）b.play(b);//第一次拷贝构造函数调用是构造形参，第二次拷贝构造函数调用是函数返回值cout<<"---------------"<<endl;Base b4=b.play(2);cout<<"---------------"<<endl;Base b5=b.play(b);cout<<"---------------"<<endl;return 0;
}

g++中执行结果为：

可以发现Base b4=b.play(2);和b.play(2);这行代码相比，析构函数的位置发生了变化，之前是连续两次析构，现在换成了先析构一次，然后函数结束后又析构一次。并且是第二次拷贝构造函数创建的对象在函数结束后析构的（根据对象的地址可以得知）。那么情况可能是这样的，即第二次拷贝构造函数是由于函数返回对象时引起的。因为在函数play调用结束后形参b会被析构掉，所以需要将b复制到一个新的内存区域。调用b.play(2)时的内存布局可能是这样的（根据上面的地址绘制）：

为了验证这个测试，可以让play函数不返回B的对象，代码如下：

#include <iostream>using namespace std;class Base{
public://构造函数Base(){cout<<"default constructor invoke!"<<(int *)this<<endl;}Base(int d){this->data=d;cout<<"constructor invoke!"<<(int *)this<<endl;}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//赋值操作符void  operator=(const Base &b){cout<<"operator constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//7构函数~Base(){cout<<"deconstructor invoke!"<<(int *)this<<endl;}void play(Base  b){}
private:int data;};int main(){Base b(1);//构造函数调用Base b2=b;//拷贝构造函数调用Base b3;//默认构造函数调用b3=b;//赋值操作符调用b.play(2);//构造函数调用b.play(b);//调用一次拷贝构造函数return 0;
}

可以发现少了一次拷贝构造函数的调用：

最后再来看看函数参数为引用的时候的情况，这种情况下不会再创建形参，函数是直接对实参进行操作：

#include <iostream>using namespace std;class Base{
public://构造函数Base(){cout<<"default constructor invoke!"<<(int *)this<<endl;}Base(int d){this->data=d;cout<<"constructor invoke!"<<(int *)this<<endl;}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//赋值操作符void  operator=(const Base &b){cout<<"operator constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//7构函数~Base(){cout<<"deconstructor invoke!"<<(int *)this<<endl;}void play(Base  b){}void refer(Base  b){cout<<"refer address:"<<(int *)&b<<endl;}
private:int data;};int main(){Base b(1);//构造函数调用Base b2=b;//拷贝构造函数调用Base b3;//默认构造函数调用b3=b;//赋值操作符调用b.play(b);//只会调用拷贝构造函数b.play(2);//构造函数调用cout<<"-----------------"<<endl;b.refer(b);cout<<"-----------------"<<endl;return 0;
}

执行结果为：

refer函数参数为引用返回对象时：

#include <iostream>using namespace std;class Base{
public://构造函数Base(){cout<<"default constructor invoke!"<<(int *)this<<endl;}Base(int d){this->data=d;cout<<"constructor invoke!"<<(int *)this<<endl;}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//赋值操作符void  operator=(const Base &b){cout<<"operator constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//7构函数~Base(){cout<<"deconstructor invoke!"<<(int *)this<<endl;}void play(Base  b){}Base refer(Base & b){cout<<"refer address:"<<(int *)&b<<endl;return b;}
private:int data;};int main(){Base b(1);//构造函数调用Base b2=b;//拷贝构造函数调用Base b3;//默认构造函数调用b3=b;//赋值操作符调用b.play(b);//只会调用拷贝构造函数b.play(2);//构造函数调用cout<<"-----------------"<<endl;b.refer(b);cout<<"-----------------"<<endl;return 0;
}

依然调用了拷贝构造函数来复制返回值：

refer函数参数为引用并且返回引用时，才不会调用拷贝构造函数：

#include <iostream>using namespace std;class Base{
public://构造函数Base(){cout<<"default constructor invoke!"<<(int *)this<<endl;}Base(int d){this->data=d;cout<<"constructor invoke!"<<(int *)this<<endl;}//拷贝构造函数Base(const Base &b){cout<<"copy constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//赋值操作符void  operator=(const Base &b){cout<<"operator constructor invoke!"<<(int *)this<<endl;this->data=b.data;}//7构函数~Base(){cout<<"deconstructor invoke!"<<(int *)this<<endl;}void play(Base  b){}Base& refer(Base & b){cout<<"refer address:"<<(int *)&b<<endl;return b;}
private:int data;};int main(){Base b(1);//构造函数调用Base b2=b;//拷贝构造函数调用Base b3;//默认构造函数调用b3=b;//赋值操作符调用b.play(b);//只会调用拷贝构造函数b.play(2);//构造函数调用cout<<"-----------------"<<endl;b.refer(b);cout<<"-----------------"<<endl;return 0;
}

输出：

注意：不能返回局部对象的引用，所以如果参数不为引用是不能返回一个引用的对象的。