C++拷贝构造函数(复制构造函数)
有的、已经存在的数据创建出一份新的数据，最终的结果是多了一份相同的数据。例如，将Word 文档拷贝到U盘去复印店打印，将D 盘的图片拷贝到桌面以方便浏览，将重要的文件上传到百度网盘以防止丢失等，都是「创建一份新数据」的意思。
在C++ 中，拷贝并没有脱离它本来的含义，只是将这个含义进行了“特化”，是指用已经存在的对象创建出一个新的对象。从本质上讲，对象也是一份数据，因为它会占用内存。
严格来说，对象的创建包括两个阶段，首先要分配内存空间，然后再进行初始化：
?分配内存很好理解，就是在堆区、栈区或者全局数据区留出足够多的字节。这个时候的内存还比较“原始”，没有被“教化”，它所包含的数据一般是零值或者随机值，没有实际的意义。
?初始化就是首次对内存赋值，让它的数据有意义。注意是首次赋值，再次赋值不叫初始化。初始化的时候还可以为对象分配其他的资源（打开文件、连接网络、动态分配内存等），或者提前进行一些计算（根据价格和数量计算出总价、根据长度和宽度计算出矩形的面积等）等。说白了，初始化就是调用构造函数。
很明显，这里所说的拷贝是在初始化阶段进行的，也就是用其它对象的数据来初始化新对象的内存。
那么，如何用拷贝的方式来初始化一个对象呢？其实这样的例子比比皆是，string 类就是一个典型的例子。
1.#include
2.#include
https://www.360docs.net/doc/0d1527851.html,ing namespace std;
4.
5.void func(string str){
6.cout< 7.} 8. 9.int main(){ 10.string s1 ="https://www.360docs.net/doc/0d1527851.html,"; 11.string s2(s1); 12.string s3 = s1; 13.string s4 = s1 +" "+ s2; 14.func(s1); 15.cout< 16. 17.return0; 18.} 运行结果： https://www.360docs.net/doc/0d1527851.html, https://www.360docs.net/doc/0d1527851.html, https://www.360docs.net/doc/0d1527851.html, https://www.360docs.net/doc/0d1527851.html, https://www.360docs.net/doc/0d1527851.html, https://www.360docs.net/doc/0d1527851.html, s1、s2、s3、s4 以及func() 的形参str，都是使用拷贝的方式来初始化的。 对于s1，表面上看起来是将一个字符串直接赋值给了s1，实际上在内部 进行了类型转换，将const char * 类型转换为string 类型后才赋值的， 这点我们将在《C++转换构造函数》一节中详细讲解。s4 也是类似的道 理。 对于s1、s2、s3、s4，都是将其它对象的数据拷贝给当前对象，以完成当前对象的初始化。 对于func() 的形参str，其实在定义时就为它分配了内存，但是此时并没有初始化，只有等到调用func() 时，才会将其它对象的数据拷贝给str 以完成初始化。 当以拷贝的方式初始化一个对象时，会调用一个特殊的构造函数，就是拷贝构造函数（Copy Constructor）。 下面的例子演示了拷贝构造函数的定义和使用： 1.#include 2.#include https://www.360docs.net/doc/0d1527851.html,ing namespace std; 4. 5.class Student{ 6.public: 7.Student(string name ="",int age =0,float score =0.0f);//普通构造函数 8.Student(const Student &stu);//拷贝构造函数（声明） 9.public: 10.void display(); 11.private: 12.string m_name; 13.int m_age; 14.float m_score; 15.}; 16. 17.Student::Student(string name,int age,float score):m_name(name),m_age(age), m_score(score){} 18. 19.//拷贝构造函数（定义） 20.Student::Student(const Student &stu){ 21.this->m_name = stu.m_name; 22.this->m_age = stu.m_age; 23.this->m_score = stu.m_score; 24. 25.cout<<"Copy constructor was called."< 26.} 27. 28.void Student::display(){ 29.cout< 30.} 31. 32.int main(){ 33.Student stu1("小明",16,90.5); 34.Student stu2 = stu1;//调用拷贝构造函数 35.Student stu3(stu1);//调用拷贝构造函数 36.stu1.display(); 37.stu2.display(); 38.stu3.display(); 39. 40.return0; 41.} 运行结果： Copy constructor was called. Copy constructor was called. 小明的年龄是16，成绩是90.5 小明的年龄是16，成绩是90.5 小明的年龄是16，成绩是90.5 第8 行是拷贝构造函数的声明，第20 行是拷贝构造函数的定义。拷贝构造函数只有一个参数，它的类型是当前类的引用，而且一般都是const 引用。 1) 为什么必须是当前类的引用呢？ 如果拷贝构造函数的参数不是当前类的引用，而是当前类的对象，那么在调用拷贝构造函数时，会将另外一个对象直接传递给形参，这本身就是一次拷贝，会再次调用拷贝构造函数，然后又将一个对象直接传递给了形参，将继续调用拷贝构造函数……这个过程会一直持续下去，没有尽头，陷入死循环。 只有当参数是当前类的引用时，才不会导致再次调用拷贝构造函数，这不仅是逻辑上的要求，也是C++ 语法的要求。 2) 为什么是const 引用呢？ 拷贝构造函数的目的是用其它对象的数据来初始化当前对象，并没有期望更改其它对象的数据，添加const 限制后，这个含义更加明确了。 另外一个原因是，添加const 限制后，可以将const 对象和非const 对象传递给形参了，因为非const 类型可以转换为const 类型。如果没有const 限制，就不能将const 对象传递给形参，因为const 类型不能转换为非const 类型，这就意味着，不能使用const 对象来初始化当前对象了。 以上面的Student 类为例，将const 去掉后，拷贝构造函数的原型变为： 此时，下面的代码就会发生错误： 1.const Student stu1("小明",16,90.5); 2.Student stu2 = stu1; 3.Student stu3(stu1); 当然，你也可以再添加一个参数为const 引用的拷贝构造函数，这样就不会出错了。换句话说，一个类可以同时存在两个拷贝构造函数，一个函数的参数为const 引用，另一个函数的参数为非const 引用。 默认拷贝构造函数 在前面的教程中，我们还没有讲解拷贝构造函数，但是却已经在使用拷贝的方式创建对象了，并且也没有引发什么错误。这是因为，如果程序员没有显式地定义拷贝构造函数，那么编译器会自动生成一个默认的拷贝构造函数。这个默认的拷贝构造函数很简单，就是使用“老对象”的成员变量对“新对象”的成员变量进行一一赋值，和上面Student 类的拷贝构造函数非常类似。 对于简单的类，默认拷贝构造函数一般是够用的，我们也没有必要再显式地定义一个功能类似的拷贝构造函数。但是当类持有其它资源时，如动态分配的内存、打开的文件、指向其他数据的指针、网络连接等，默认拷贝构造函数就不能拷贝这些资源，我们必须显式地定义拷贝构造函数，以完整地拷贝对象的所有数据，这点我们将在《C++深拷贝和浅拷贝》一节中深入讲解。 C#默认构造函数的作用 本文详细介绍C#默认构造函数的作用 构造函数主要用来初始化对象。它又分为静态(static)和实例(instance)构造函数两种类别。大家应该都了解如果来写类的构造函数，这里只说下默认构造函数的作用，以及在类中保留默认构造函数的重要性。实际上，我说错了。正确的说法是：以及在类中保留空参数构造函数的重要性。我们来写一个类A，代码如下： view plaincopy to clipboardprint? public class A { public int Number; //数字 public string Word; //文本 } //在Test类中实例化 public class Test { static void Main() { A a = new A(); //实例化，A()即为类A的默认构造函数 Console.WriteLine(“Number = {0}"nWord = {1}”,a.Number,a.Word); Console.read(); } } 输出的结果是： Number = 0 Word = ******************************* using System; class Point { public int x, y,z; public Point() { x = 0; y = 0; z = 0; } public Point(int x, int y,int z) { //把函数内容补充完整 this.x = x; this.y =y; this.z =z; } public override string ToString() { return(String.Format("({0},{1},{2})", x, y,z)); } } class MainClass { static void Main() { Point p1 = new Point(); Point p2 = new Point(10,20,30); Console.WriteLine("三维中各点坐标："); Console.WriteLine("点1的坐标为{0}", p1); Console.WriteLine("点2的坐标为{0}", p2); } } ******************************************************************************* ********* C#类的继承,构造函数实现及其调用顺序 类层层派生,在实例化的时候构造函数的调用顺序是怎样的? --从顶层基类开始向子类方向顺序调用无参构造. 默认构造(无参构造)和带参构造什么时候调用?--默认将从顶层父类的默认构造一直调用到当前类的默认构造. 下面是示例: /**//*--===------------------------------------------===--- 作者：许明会 日期：类的派生和构造函数间的关系,调用层次及实现 日期：2008年1月18日 17:30:43 若希望类能够有派生类,必须为其实现默认构造函数. 若类没有实现带参构造,编译器将自动创建默认构造函数. 若类实现了带参构造,则编译器不会自动生成默认构造. --===------------------------------------------===---*/ using System; namespace xumh { public class MyClass { public MyClass () { 有的、已经存在的数据创建出一份新的数据，最终的结果是多了一份相同的数据。例如，将Word 文档拷贝到U盘去复印店打印，将D 盘的图片拷贝到桌面以方便浏览，将重要的文件上传到百度网盘以防止丢失等，都是「创建一份新数据」的意思。 在C++ 中，拷贝并没有脱离它本来的含义，只是将这个含义进行了“特化”，是指用已经存在的对象创建出一个新的对象。从本质上讲，对象也是一份数据，因为它会占用内存。 严格来说，对象的创建包括两个阶段，首先要分配内存空间，然后再进行初始化： ?分配内存很好理解，就是在堆区、栈区或者全局数据区留出足够多的字节。这个时候的内存还比较“原始”，没有被“教化”，它所包含的数据一般是零值或者随机值，没有实际的意义。 ?初始化就是首次对内存赋值，让它的数据有意义。注意是首次赋值，再次赋值不叫初始化。初始化的时候还可以为对象分配其他的资源（打开文件、连接网络、动态分配内存等），或者提前进行一些计算（根据价格和数量计算出总价、根据长度和宽度计算出矩形的面积等）等。说白了，初始化就是调用构造函数。 很明显，这里所说的拷贝是在初始化阶段进行的，也就是用其它对象的数据来初始化新对象的内存。 那么，如何用拷贝的方式来初始化一个对象呢？其实这样的例子比比皆是，string 类就是一个典型的例子。 1.#include 定义类的构造函数 作者：lyb661 时间：20150613 定义类的构造函数有如下几种方法： 1、使用默认构造函数(类不另行定义构造函数)：能够创建一个类对象，但不能初始化类的各个成员。 2、显式定义带有参数的构造函数：在类方法中定义，使用多个参数初始化类的各个数据成员。 3、定义有默认值的构造函数：构造函数原型中为类的各个成员提供默认值。 4、使用构造函数初始化列表：这个构造函数初始化成员的方式显得更紧凑。 例如：有一个学生类。其中存储了学生的姓名、学号和分数。 class Student { private: std::string name; long number; double scores; public: Student(){}//1:default constructor Student(const std::string& na,long nu,double sc); Student(const std:;string& na="",long nu=0,double sc=0.0); Student(const std:;string& na="none",long nu=0,double sc=0.0):name(na),number(nu),scores(sc){} ……….. void display() const; //void set(std::string na,long nu,double sc); }; ......... Student::Student(const std::string& na,long nu,double sc) { name=na; number=nu; scores=sc; } void Student::display()const { std::cout<<"Name: "< 拷贝构造函数 一. 什么是拷贝构造函数 首先对于普通类型的对象来说，它们之间的复制是很简单的，例如： int a = 100; int b = a; 而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。 #include private: int a; public: //构造函数 CExample(int b) { a = b;} //拷贝构造函数 CExample(const CExample& C) { a = C.a; } //一般函数 void Show () { cout< 1．为什么要引入构造函数和析构函数？ 对象的初始化是指对象数据成员的初始化，在使用对象前，一定要初始化。由于数据成员一般为私有的(private)，所以不能直接赋值。对对象初始化有以下两种方法：类中提供一个普通成员函数来初始化，但是会造成使用上的不便（使用对象前必须显式调用该函数）和不安全(未调用初始化函数就使用对象)。 当定义对象时，编译程序自动调用构造函数。 析构函数的功能是当对象被撤消时，释放该对象占用的内存空间。析构函数的作用与构造函数正好相反，一般情况下，析构函数执行构造函数的逆操作。在对象消亡时，系统将自动调用析构函数，执行一些在对象撤消前必须执行的清理任务。 2. 类的公有、私有和保护成员之间的区别是什么？ ①私有成员private: 私有成员是在类中被隐藏的部分，它往往是用来描述该类对象属性的一些数据成员，私有成员只能由本类的成员函数或某些特殊说明的函数（如第4章讲到的友员函数）访问，而类的外部根本就无法访问，实现了访问权限的有效控制，使数据得到有效的保护，有利于数据的隐藏，使内部数据不能被任意的访问和修改，也不会对该类以外的其余部分造成影响，使模块之间的相互作用被降低到最小。private成员若处于类声明中的第一部分，可省略关键字private。 ②公有成员public：公有成员对外是完全开放的，公有成员一般是成员函数，它提供了外部程序与类的接口功能，用户通过公有成员访问该类对象中的数据。 ③保护成员protected: 只能由该类的成员函数，友元，公有派生类成员函数访问的成员。保护成员与私有成员在一般情况下含义相同，它们的区别体现在类的继承中对产生的新类的影响不同，具体内容将在第5章中介绍。缺省访问控制（未指定private、protected、public访问权限）时，系统认为是私有private 成员。 3. 什么是拷贝构造函数，它何时被调用？ 实验7拷贝构造函数 一、实验目的 (1) 掌握类的声明和对象的声明。 (2) 掌握拷贝构造函数的定义与使用 (3) 了解拷贝构造函数调用的时机 二、实验内容及步骤 1 新建c++源文件，找到week14文件夹中的copyStruDefine.cpp文件，复制到新建的源文件中运行，将运行结果记录下来，分析程序中执行哪条语句引起拷贝构造函数被调用的，将该语句的行号记录下来。 分析程序，第46 条语句Point pa(1,2) 执行时会调用构造函数，第47 条语句 Point pb=pa 执行时会调用拷贝构造函数。 2 程序中添加一个distance函数，用来计算2个点之间的距离。代码如下： 运行程序，记录运行结果。 分析程序，第52,53 条语句Point pa(7,4); Point pb(1,2); 执行时会调用构造函数，第46,47 条语句 double dx=a1.getX()-a2.getX();double dy=a1.getY()-a2.getY(); 执行时会调用拷贝构造函数。 3 设计一个函数mirror用来返回一个点在x轴的镜像坐标，如点A坐标为（1，2），它的镜像点A’坐标为（1，-2）。 分析：函数的结构分成2部分，函数头部和函数体 （1）函数的函数头部分语法格式：返回类型函数名（参数） 可以确定的是函数名mirror；这个函数会计算出一个点的镜像并返回，点的镜像还是一个点，因此可以确定函数的返回类型是void ；这个函数会将某个点的镜像计算出来，那到底计算的是那个点的镜像呢？这是不确定的，将不确定的因素定义为函数的参数，因此函数的参数类型是Point ；现将函数的第一行补充完整。 返回类型mirror（参数） （2）分析函数的函数体部分，即用”{ }”包围的部分。 我们通过参数传递接收到一个点的坐标，现在要计算另一个点的坐标（镜像点），因此需要在函数体内定义另外一个点类型的对象来存放镜像点的坐标。将镜像点的x坐标赋值为参数点的x坐标值，将镜像点的y坐标赋值为参数点的y坐标值的负数值（需要注意Point类中的x和y成员都是私有的）。将镜像点坐标赋值完成后，用return语句将镜像点返回。 （3）在主函数中测试mirror函数。 #include c++构造函数的知识在各种c++教材上已有介绍，不过初学者往往不太注意观察和总结其中各种构造函数的特点和用法，故在此我根据自己的c++编程经验总结了一下c++中各种构造函数的特点，并附上例子，希望对初学者有所帮助。 c++类的构造函数详解 一、构造函数是干什么的 class Counter { public: // 类Counter的构造函数 // 特点：以类名作为函数名，无返回类型 Counter() { m_value = 0; } private: // 数据成员 int m_value; } 该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数->由构造函数完成成员的初始化工作 eg: Counter c1; 编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter( )自动地初始化对象c1的m_value值设置为0 故： 构造函数的作用：初始化对象的数据成员。 二、构造函数的种类 class Complex { private : double m_real; double m_imag; public: // 无参数构造函数 // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做 // 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来 Complex(void) { m_real = 0.0; m_imag = 0.0; } // 一般构造函数（也称重载构造函数） // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理） // 例如：你还可以写一个Complex( int num)的构造函数出来 // 创建对象时根据传入的参数不同调用不同的构造函数 Complex(double real, double imag) { m_real = real; m_imag = imag; } // 复制构造函数（也称为拷贝构造函数） // 复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中// 若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询有关“浅拷贝”、“深拷贝”的文章论述 Complex(const Complex & c) { // 将对象c中的数据成员值复制过来 m_real = c.m_real; m_img = c.m_img; } // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象 // 例如：下面将根据一个double类型的对象创建了一个Complex对象 Complex::Complex(double r) { m_real = r; m_imag = 0.0; C++拷贝函数详解 1.什么是拷贝构造函数： CA(const CA& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构 造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参 数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。 当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷 贝构造函数就会被自动调用。 也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数： ①程序中需要新建立一个对象，并用另一个同类的对象对它初始化，如前面介绍的那样。 ②当函数的参数为类的对象时。 在调用函数时需要将实参对象完整地传递给形参，也就是需要建立一个实参的拷贝，这就 是按实参复制一个形参，系统是通过调用复制构造函数来实现的，这样能保证形参具有和实参 完全相同的值。 ③函数的返回值是类的对象。 在函数调用完毕将返回值带回函数调用处时。 此时需要将函数中的对象复制一个临时对象并传给该函数的调用处。如 Box f( ) //函数f的类型为Box类类型 {Box box1(12,15,18); return box1; //返回值是Box类的对象 } int main( ) {Box box2; //定义Box类的对象box2 box2=f( ); //调用f函数，返回Box类的临时对象，并将它赋值给 box2 } 如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的 拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。 自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。 浅拷贝和深拷贝 在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的 设计者往往对使用者抱有很多期望，希望使用者遵循一些共同的约束，但是期望总是很难得到满足的，从基础的设计原则上来说，我们不应该对设计者抱有太多的期望，宁愿予以更多的使用约束，即只有固定的路线可走。 如果你觉得某项语法规定不合理，那么请自行模拟它的种种特性，你会发现它是有道理的，只不过有时它可能会产生很多危害性，但是不应该忽略其有益的方面。 1.四种C++风格的类型转换 a. static_cast: 纯粹的内容转换，可能会造成实际内容的损失； b. dynamic_cast: 只对有虚类型有用，因为虚表的存在才有RTTI； c. const_cast： 去const化； d. reinterpret_cast: 让编译器以该转换所注明的类型去看待内存段所表示的类型，一般是针对指针类型，一般来说是不怎么安全的，而且对于函数指针的转换有时是不可移植的，因为不同编译器可能有不同的函数指针表示法（命令方法和存储方法的不同？）； 2.数据类型转换： a. double=int/int;//做法是错误的，右侧不会提升至double再进行运算的，类型提升的原则是如果不大于整型则会提升至int，但有更大类型则会继续提升，正确写法是： double=int/(double)int;或者double=(double)int/(double)int; b. int=usigned char;//错误，正确做法：usigned char->usignedint->int 3.new operator和operator new: 前者是个操作符名称，后者则代表某个函数。 new operator:new操作符仅仅是我们常见的new的名称，它实际代表两段操作：operator new （这是一个我们可以自行重载的函数，作用是分配内存，并返回所分配内存的首地址，换句话说，即使有意进行偏离或者像malloc一样设置一定字节进行特殊用途都是可以的）和调用构造函数。记住编译器看见new操作符时意味着它会先调用new操作函数（operator new()），然后调用构造函数。 上图说明了定位new和定位delete为何是类型对应的关系。 请问在构造函数中使用初始化清单和直接在构造函数内初始化成员变量有什么区别？ 比如： construct_function():var1(1),var2(2),var(3) {} 和 construct_function() { var1 = 1; var2 = 2; var3 = 3; } 有没有什么本质区别？ =============================================================================== ======= construct_function():var1(1),var2(2),var(3) {} 初始化 construct_function() { var1 = 1; var2 = 2; var3 = 3; }赋值 首先把数据成员按类型分类 1、内置数据类型，复合类型（指针，引用） 2、用户定义类型（类类型） 分情况说明： 对于类型1，在成员初始化列表和构造函数体内进行，在性能和结果上都是一样的。要是const类型的话只能使用初始化列表。 对于类型2，结果上相同，但是性能上存在很大的差别。 因为类类型的数据成员对象在进入函数体是已经构造完成，也就是说在成员初始化列表处进行构造对象的工作，这是调用一个构造函数，在进入函数体之后，进行的是对已经构造好的类对象赋值，又调用其拷贝赋值操作符才能完成（如果并未提供，则使用编译器提供的默认按成员赋值行为）。 举个例说明 class A； class B { public: B(){a = 3;} private: A a; } class A { public: A(){} A(int){value = 3;} int value; } 像上面，我们使a对象的value为3，调用一个A的构造函数＋一个默认拷贝赋值符，才达到目的。B::B()：a（3）{} 像这样，只调用了一个构造函数就得到了所需的对象啦，所以性能好。 注意：对于const成员，无缺省构造函数的类对象成员，均需放在成员初始化列表。 再举个例子： class A { public: A(int i){} }; class B { public: B() : ci(3), a(3){} private: const int ci; A a; }; int main() { B b; return 0; } 对于const成员，无缺省构造函数的类对象成员，均需放在成员初始化列表。 一、拷贝构造函数 如果类中没有说明拷贝构造函数，则系统自动生成一个缺省复制构造函数，作为该类的公有成员 也可以进行自定义拷贝构造函数 自定义拷贝构造函数的例子： Test::Test(const Test& other) : num_(other.num_) { //num_ = other.num_; cout<<"Initializing with other "< 1、选择题 1、___A__只能访问静态成员变量。 A 静态函数 B 虚函数 C 构造函数 D 析构函数 2、下列的各类函数中，__C___不是类的成员函数。 A 构造函数 B 析构函数C友元函数 D 拷贝构造函数 3、友元的作用_A__。 A 提高程序的运行效率 B 加强类的封装性 C 实现数据的隐藏性 D 增加成员函数的种类 4、类模板的使用实际上是将类模板实例化成一个具体的_D____。 A 类 B 对象 C 函数 D 模板类 5、下列函数中，___C__不能重载。 A 成员函数 B 非成员函数 C 析构函数 D 构造函数 6、___C__是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。 A 虚析构函数B虚构造函数C纯虚函数 D 静态成员函数 7、__A___是istream的派生类，处理文件输入；___C__是iostream的派生类，可以同时处理文件的I/O。 A、ifstream B、ostream C、fstream D、ofstream 8、对于派生类的构造函数，在定义对象时构造函数的执行顺序为： 先执行__A___，再执行__B___，后执行__C___。 A 成员对象的构造函数 B 基类的构造函数 C 派生类本身的构造函数 9、局部变量可以隐藏全局变量，那么在有同名全局变量和局部变量的情形时，可以用__A___提供对全局变量的访问。 A 域运算符 B 类运算符 C 重载 D 引用 10、一个__C___允许用户为类定义一种模式，使得类中的某些数据成员及某些成员函数的返回值能取任意类型。 A 函数模板 B 模板函数 C 类模板 D 模板类 11、系统在调用重载函数时，往往根据一些条件确定哪个重载函数被调用，在下列选项中，不能作为依据的是___D__。 A 参数个数 B 参数的类型 C 函数名称D函数的类型 12、如果一个类至少有一个纯虚函数，那么就称该类为__A___。 A 抽象类 B 虚基类 C 派生类 D 以上都不对 13、进行文件操作时需要包含__B___文件。 A iostream B fstream C stdio.h D stdliB、h 14、在C++中，打开一个文件，就是将这个文件与一个__B___建立关联；关闭一 class Person { private String name=""; private int age=0; public Person() { System.out.println("person无参数构造函数"); } public Person(String name,int age) { https://www.360docs.net/doc/0d1527851.html,=name; this.age=age; System.out.println("person 2 参数的构造函数"); } } class Student extends Person { private String school; private String grade; public Student() { System.out.println("student 无参数的构造函数"); } public Student(String name ,int age,String school) { System.out.println("student 3 参数的构造函数"); } public Student(String name ,int age,String school,String grade) { super(name,age); this.school=school; this.grade=grade; System.out.println("student 4 参数的构造函数，super()."); } } class Test { public static void main(String [] args) { System.out.println("st1:"); Student st2=new Student(); System.out.println("---------------------------"); System.out.println("st2:"); Student st=new Student("zhangshan",76,"武大"); System.out.println("---------------------------"); System.out.println("st3:"); Student st3=new Student("lisi",24,"武大","研究生"); } } /* ======================================= 输出如下： E:JavaWork>java Test st1: person无参数构造函数 student 无参数的构造函数 --------------------------- st2: person无参数构造函数 student 3 参数的构造函数 --------------------------- st3: C++拷贝构造函数的几个细节 关键字: c++ 拷贝构造函数是C++最基础的概念之一，大家自认为对拷贝构造函数了解么？请大家先回答一下三个问题: 1.以下函数哪个是拷贝构造函数,为什么? 1.X::X(const X&); 2.X::X(X); 3.X::X(X&, int a=1); 4.X::X(X&, int a=1, b=2); 2.一个类中可以存在多于一个的拷贝构造函数吗? 3.写出以下程序段的输出结果, 并说明为什么?如果你都能回答无误的话，那么你已经对拷贝构造函数有了相当的了解。 1.#include b) const X& c) volatile X& d) const volatile X& 且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数. 1.X::X(const X&); //是拷贝构造函数 2.X::X(X&, int=1); //是拷贝构造函数 2.类中可以存在超过一个拷贝构造函数, 1.class X { 2.public: 3. X(const X&); 4. X(X&); // OK 5.}; 注意,如果一个类中只存在一个参数为X&的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化. 1.class X { 2.public: 3. X(); 4. X(X&); 5.}; 6. 7.const X cx; 8.X x = cx; // error 如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝 构造函数. 这个默认的参数可能为X::X(const X&)或X::X(X&),由编译器根据上下文决定选择哪一个. 默认拷贝构造函数的行为如下: 默认的拷贝构造函数执行的顺序与其他用户定义的构造函数相同,执行先父类后子类的构造. 拷贝构造函数对类中每一个数据成员执行成员拷贝(memberwise Copy)的动作. a)如果数据成员为某一个类的实例,那么调用此类的拷贝构造函数. b)如果数据成员是一个数组,对数组的每一个执行按位拷贝. c)如果数据成员是一个数量,如int,double,那么调用系统内建的赋值运算符 对其进行赋值. 3. 拷贝构造函数不能由成员函数模版生成. C++拷贝构造函数的知识点总结 一拷贝构造函数是C++最基础的概念之一，大家自认为对拷贝构造函数了解么？请大家先回答一下三个问题: 1.以下函数哪个是拷贝构造函数,为什么? 1.X::X(const X&); 2.X::X(X); 3.X::X(X&, int a=1); 4.X::X(X&, int a=1, b=2); 2.一个类中可以存在多于一个的拷贝构造函数吗? 3.写出以下程序段的输出结果, 并说明为什么?如果你都能回答无误的话，那么你已经对拷贝构造函数有了相当的了解。 1.#include 2.#include 3. 4.struct X { 5. template d) const volatile X& 且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数. 1.X::X(const X&); //是拷贝构造函数 2.X::X(X&, int=1); //是拷贝构造函数 2.类中可以存在超过一个拷贝构造函数, 1.class X { 2.public: 3. X(const X&); 4. X(X&); // OK 5.}; 注意,如果一个类中只存在一个参数为X&的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化. 1.class X { 2.public: 3. X(); 4. X(X&); 5.}; 6. 7.const X c x; 8.X x = c x; // error 如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数. 这个默认的参数可能为X::X(const X&)或X::X(X&),由编译器根据上下文决定选择哪一个. 默认拷贝构造函数的行为如下: 默认的拷贝构造函数执行的顺序与其他用户定义的构造函数相同,执行先父类后子类的构造. 拷贝构造函数对类中每一个数据成员执行成员拷贝(memberwise Copy)的动作. a)如果数据成员为某一个类的实例,那么调用此类的拷贝构造函数. b)如果数据成员是一个数组,对数组的每一个执行按位拷贝. c)如果数据成员是一个数量,如int,double,那么调用系统内建的赋值运算符对其进行赋值. 3.拷贝构造函数不能由成员函数模版生成. 1.struct X { 2.template C#构造函数是在创建给定类型的对象时执行的类方法。构造函数具有与类相同的名称，它通常初始化新对象的数据成员。不带参数的构造函数称为“默认构造函数”。无论何时，只要使用new 运算符实例化对象，并且不为new 提供任何参数，就会调用默认构造函数。除非类是static 的，否则C# 编译器将为无构造函数的类提供一个公共的默认构造函数，以便该类可以实例化。 构造函数必须是在类里的一级声明，并且命名为类名， 形式为：修饰符类名（参数类型1，参数名1，。。。） 例如 class A { public int x, y; public string s; // 默认构造函数 public A() { x = 0; y = 0; } //带参数的构造函数 public A(string a) { this.s=a; } } 一般函数的声明则不受这些约束 只要定义在命名空间内，命名形式为：修饰符返回值类型函数名（参数类型1，参数名1，。。。） 例如:private static void Main(string args) 声明了一个私有的静态主函数，无返回值，参数为args，string类型vvv 一、C#构造函数？Construct,Function 构造函数是一种特殊的成员函数,它主要用于为对象分配存储空间,对数据成员进行初始化. 构造函数具有一些特殊的性质: (1)构造函数的名字必须与类同名; (2)构造函数没有返回类型,它可以带参数,也可以不带参数; (3)声明类对象时,系统自动调用构造函数,构造函数不能被显式调用; (4)构造函数可以重载,从而提供初始化类对象的不同方法; (5)若在声明时未定义构造函数,系统会自动生成默认的构造函数,此时构造函数的函数体为空. C++类的构造函数和复制构造函数 [日期：2011-03-11] 来源：LinuxLinux 作者：pcliuguangtao 首先，我们先看一个小小的问题： #include 那么怎样才叫显式的调用那？ 比如已经有一个Student类 class Student { public: Student(int num,int score ): m_number( num ),m_score(score ){} Studnet( ){} //默认构造函数 void PrintInfo( ) { cout<C默认构造函数的作用
C++拷贝构造函数(复制构造函数)
定义构造函数的四种方法
(完整版)拷贝构造函数
为什么要引入构造函数和析构函数汇总
拷贝构造函数
构造函数
【重要】C++拷贝函数详解 20150111
所学知识点总结
构造函数初始化成员变量
拷贝构造函数&默认拷贝构造函数&拷贝构造函数调用几种情况
C++考试题(选择题)
Java默认构造函数的作用
C++拷贝构造函数的几个细节
C拷贝构造函数的几个知识点总结及示例代码
C#中构造函数使用方法
C++类的构造函数和复制构造函数