C++类的构造函数和复制构造函数

合集下载

详解C++中构造函数,拷贝构造函数和赋值函数的区别和实现

详解C++中构造函数,拷贝构造函数和赋值函数的区别和实现

详解C++中构造函数,拷贝构造函数和赋值函数的区别和实现C++中⼀般创建对象,拷贝或赋值的⽅式有构造函数,拷贝构造函数,赋值函数这三种⽅法。

下⾯就详细⽐较下三者之间的区别以及它们的具体实现1.构造函数构造函数是⼀种特殊的类成员函数,是当创建⼀个类的对象时,它被调⽤来对类的数据成员进⾏初始化和分配内存。

(构造函数的命名必须和类名完全相同)⾸先说⼀下⼀个C++的空类,编译器会加⼊哪些默认的成员函数默认构造函数和拷贝构造函数析构函数赋值函数(赋值运算符)取值函数**即使程序没定义任何成员,编译器也会插⼊以上的函数!注意:构造函数可以被重载,可以多个,可以带参数;析构函数只有⼀个,不能被重载,不带参数⽽默认构造函数没有参数,它什么也不做。

当没有重载⽆参构造函数时,A a就是通过默认构造函数来创建⼀个对象下⾯代码为构造函数重载的实现<span style="font-size:14px;">class A{int m_i;Public:A(){Cout<<”⽆参构造函数”<<endl;}A(int i):m_i(i) {} //初始化列表}</span>2.拷贝构造函数拷贝构造函数是C++独有的,它是⼀种特殊的构造函数,⽤基于同⼀类的⼀个对象构造和初始化另⼀个对象。

当没有重载拷贝构造函数时,通过默认拷贝构造函数来创建⼀个对象A a;A b(a);A b=a; 都是拷贝构造函数来创建对象b强调:这⾥b对象是不存在的,是⽤a 对象来构造和初始化b的!!先说下什么时候拷贝构造函数会被调⽤:在C++中,3种对象需要复制,此时拷贝构造函数会被调⽤1. 1)⼀个对象以值传递的⽅式传⼊函数体2. 2)⼀个对象以值传递的⽅式从函数返回3. 3)⼀个对象需要通过另⼀个对象进⾏初始化什么时候编译器会⽣成默认的拷贝构造函数:1. 1)如果⽤户没有⾃定义拷贝构造函数,并且在代码中使⽤到了拷贝构造函数,编译器就会⽣成默认的拷贝构造函数。

C++自测题之三

C++自测题之三

一选择题1、面向对象程序设计中的数据隐藏指的是( D )。

A. 输入数据必须输入口令B. 数据经过加密处理C. 对象部数据结构上建有防火墙D. 对象部数据结构的不可访问性2、以下关于类的访问权限的描述中,错误的选项是( D ).。

A. 说明为公有的成员可以被程序中的任何代码访问B. 说明为私有的成员只能被类的成员和说明为友元类的成员函数访问C.说明为保护的成员,除了能被本身的成员函数和说明为友元类的成员函数访问外,该类的派生类的成员也可以访问D. 类的所有成员都可以被程序中的任何代码访问3、 C 中对于类中定义的成员,其默认的访问权限为( C )。

A. PublicB. ProtectedC. PrivatD. Static4、C++ 对C语言作了很多改良,即从面向过程变成为面向对象的主要改良是( D )A. 增加了一些新的运算符B. 允许函数重载,并允许设置缺省参数C. 规定函数说明符必须用原型D. 引进了类和对象的概念5、类A中的一个成员函数的说明如下:void Set(A &a);那么该函数的参数“A &a〞的含义是( C )。

A. 指向A的指针为aB. 将变量a的地址赋给类AC. 类A对象引用a用作函数的形参D. 变量A与a按位与后作函数参数6、以下特性中,C与C++共有的是( D )。

A. 继承B. 封装C. 多态性D. 函数定义不能嵌套7、关于封装,以下说法中不正确的选项是〔 D 〕。

A. 通过封装,对象的全部属性和操作结合在一起,形成一个整体B. 通过封装,一个对象的实现细节被尽可能地隐藏起来〔不可见〕C. 通过封装,每个对象都成为相对独立的实体D. 通过封装,对象的属性都是不可见的8、在一个类的定义中,包含有〔 C 〕成员的定义。

A. 数据B. 函数C.数据和函数D. 数据或函数9、在类作用域中能够通过直接使用该类的〔 D 〕成员名进展访问。

A. 私有B. 公用C. 保护D. 任何10、在关键字public后面定义的成员为类的〔 B 〕成员。

c++练习题(带答案)

c++练习题(带答案)

一、选择题1.C++语言属于( C )。

A)自然语言 B)机器语言 C)面向对象语言D)汇编语言2.下面选项中不属于面向对象程序设计特征的是(C) 。

A)继承性 B)多态性 C)相似性 D)封装性3.可用作C++语言用户标识符的一组标识符是( B )。

A) void define +WORD B) a3_b3 _123 YNC) for -abc Case D) 2a DO sizeof4.假定一个二维数组的定义语句为“inta[3][4]={{3,4},{2,8,6}};”,则元素a[2][1]的值为(A)。

A) 0 B) 4 C) 8 D) 65.下列情况中,哪一种情况不会调用拷贝构造函数( B )?A)用派生类的对象去初始化基类对象时B)将类的一个对象赋值给该类的另一个对象时C)函数的形参是类的对象,调用函数进行形参和实参结合时D)函数的返回值是类的对象,函数执行返回调用者时6.以下哪一关键字可用于重载函数的区分(C)A)extern B)static C)const D)virtual7.下列有关数组的叙述中,正确的是( B )A)C++中数组的存储方式为列优先存储B)数组名可以作为实参赋值给指针类型的形参C)数组下标索引从1开始,至数组长度n结束D)数组指针的语法形式为:类型名 *数组名[下标表达式];8.下列有关继承和派生的叙述中,正确的是( C )A)派生类不能访问通过私有继承的基类的保护成员B)多继承的虚基类不能够实例化C)如果基类没有默认构造函数,派生类就应当声明带形参的构造函数D)基类的析构函数和虚函数都不能够被继承,需要在派生类中重新实现9.实现运行时多态的机制是( A )A)虚函数B)重载函数C)静态函数D)模版函数10.若有下面的函数调用:fun(a+b, 3, max(n-1, b));其中实参的个数是( A)A)3 B)4 C)5 D)611.下列关于this指针的说法正确的是( B)A)this指针存在于每个函数之中B)在类的非静态函数中this指针指向调用该函数的对象C)this指针是指向虚函数表的指针D)this指针是指向类的函数成员的指针12.在下列关于C++函数的叙述中,正确的是(C)A)每个函数至少要有一个参数B)每个函数都必须返回一个值C)函数在被调用之前必须先声明D)函数不能自己调用自己13.下列运算符中,不能重载的是(C)A)&& B)!= C). D)->14.下面程序的输出结果是(B)#include <iostream>using namespace std;int i = 0;int fun(int n){static int a = 2;a++;return a+n;}void main(){int k = 5;{int i = 2;k += fun(i);}k += fun(i);cout << k;}A)13 B)14 C)15 D)1615.下面的程序段的运行结果为(D)char str[] = "job", *p = str;cout << *(p+2) << endl;A)98 B)无输出结果 C)字符’b’的地址 D)字符’b’16.下面程序的输出结果是( C )#include <iostream>using namespace std;class A{public:A (int i) { x = i; }void dispa () { cout << x << “,”; }private :int x ;};class B : public A{public:B(int i) : A(i+10) { x = i; }void dispb() { dispa(); cout << x << endl; }private :int x ;};void main(){B b(2);b.dispb();}A)10,2 B)12,10 C)12,2 D)2,217.下面程序的输出结果是( C)?#include <iostream>using namespace std;class Base{public:Base(int i) { cout << i; }~Base () { }};class Base1: virtual public Base{public:Base1(int i, int j=0) : Base(j) { cout << i; }~Base1() {}};class Base2: virtual public Base{public:Base2(int i, int j=0) : Base(j) { cout << i; }~Base2() {}};class Derived : public Base2, public Base1{public:Derived(int a, int b, int c, int d) : mem1(a), mem2(b), Base1(c), Base2(d), Base(a){ cout << b; }private:Base2 mem2;Base1 mem1;};void main() { Derived objD (1, 2, 3, 4); }A)134122 B)123412 C)14302012 D)14321218.下面程序的输出结果是(C)#include <iostream>using namespace std;class Base{public:virtual void f() { cout << “f0+”; }void g() { cout << “g0+”; }};class Derived : public Base{public:void f() { cout << “f+”; }void g() { cout << “g+”; }};void main() { Derived d; Base *p = &d; p->f();p->g(); }A)f+g+ B)f0+g+ C)f+g0+ D)f0+g0+19.下面程序的输出结果是( C )#include <iostream>using namespace std;class Sample{friend long fun (Sample s){if (s.x < 2) return 1;return s.x * fun(Sample(s.x-1));}public:Sample (long a) { x = a; }private:long x;};void main(){int sum = 0;for (int i=0; i<4; i++){sum += fun(Sample(i));}cout << sum;}A)12 B)16 C)10 D)34 20.以下程序的输出结果是:(D)#include <iostream>using namespace std;int fun(char *s){ char *p=s;while (*p!='\0') p++;return (p-s);}void main(){cout<<fun("abc")<<endl;}A.0 B. 1 C. 2 D. 321.有如下程序段:int i=1;while(1){i++;if (i==10) break;if(i%2==0) cout<<’*’;}执行这个程序段输出字符*的个数是(C)A. 10B. 3C. 4D.522.下列关于虚基类的描述中,错误的是(C)A. 使用虚基类可以消除由多继承产生的二义性B. 构造派生类对象时,虚基类的构造函数只被调用一次C. 声明 class B:virtual public A 说明类B为虚基类D. 建立派生类对象时,首先调用虚基类的构造函数23.有下类定义Class A {Char *a;Public:A():a(0){}A(char *aa) {//把aa所指字符串拷贝到a所指向的存储空间A=___________________;Strcpy(a,aa);~A() {delete [] a;}};正确的选择是(A)A. new char[strlen(aa)+1]B. char[strlen(aa)+1]C. char[strlen(aa)]D. newchar[sizeof(aa)-1]24.假定AA为一个类,a为该类私有的数据成员,GetValue( )为该类公有函数成员,它返回a的值,x为该类的一个对象,则访问x对象中数据成员a的格式为(d )。

C++在单继承、多继承、虚继承时,构造函数、复制构造函数、赋值操作符、析构函数的执行顺序和执行内容

C++在单继承、多继承、虚继承时,构造函数、复制构造函数、赋值操作符、析构函数的执行顺序和执行内容

C++在单继承、多继承、虚继承时,构造函数、复制构造函数、赋值操作符、析构函数的执⾏顺序和执⾏内容⼀、本⽂⽬的与说明1. 本⽂⽬的:理清在各种继承时,构造函数、复制构造函数、赋值操作符、析构函数的执⾏顺序和执⾏内容。

2. 说明:虽然复制构造函数属于构造函数的⼀种,有共同的地⽅,但是也具有⼀定的特殊性,所以在总结它的性质时将它单独列出来了。

3. 单继承、多继承、虚继承,既然都属于继承,那么虽然有⼀定的区别,但还是相同点⽐较多。

如果放在⼀块讲,但为了将内容制作成递进的,就分开了,对相同点进⾏重复,(⼤量的复制粘贴哈),但在不同点进⾏了标注。

注意:三块内容是逐步递进的如果你懂虚函数,那么单继承和多继承那块你就可以不看;如果你懂多继承,那单继承你就不要看了,⾄于虚继承就等你懂虚继承再回来看吧;如果你只懂单继承,那你就只看单继承就好。

⼆、基本知识1. 对于⼀个空类,例如:class EmptyClass{};虽然你没有声明任何函数,但是编译器会⾃动为你提供上⾯这四个⽅法。

class EmptyClass {public:EmptyClass(); // 默认构造函数EmptyClass(const EmptyClass &rhs); // 复制构造函数~EmptyClass(); // 析构函数EmptyClass& operator=(const EmptyClass &rhs); // 赋值运算符}对于这四个⽅法的任何⼀个,你的类如果没有声明,那么编译器就会⾃动为你对应的提供⼀个默认的(注意合成默认构造函数是⽤于没有编写构造函数编译器才会合成默认构造函数,其中复制构造函数也是构造函数)。

(在《C++ primer》中,这个编译器⾃动提供的版本叫做“合成的***”,例如合成的复制构造函数)当然如果你显式声明了,编译器就不会再提供相应的⽅法。

2. 合成的默认构造函数执⾏内容:如果有⽗类,就先调⽤⽗类的默认构造函数。

C++拷贝(复制)构造函数详解

C++拷贝(复制)构造函数详解

C++拷贝(复制)构造函数详解⼀. 什么是拷贝构造函数⾸先对于普通类型的对象来说,它们之间的复制是很简单的,例如:[c-sharp]1. int a = 100;2. int b = a;⽽类对象与普通对象不同,类对象内部结构⼀般较为复杂,存在各种成员变量。

下⾯看⼀个类对象拷贝的简单例⼦。

[c-sharp]1. #include <iostream>2. using namespace std;3.4. class CExample {5. private:6. int a;7. public:8. //构造函数9. CExample(int b)10. { a = b;}11.12. //⼀般函数13. void Show ()14. {15. cout<<a<<endl;16. }17. };18.19. int main()20. {21. CExample A(100);22. CExample B = A; //注意这⾥的对象初始化要调⽤拷贝构造函数,⽽⾮赋值23. B.Show ();24. return 0;25. }运⾏程序,屏幕输出100。

从以上代码的运⾏结果可以看出,系统为对象 B 分配了内存并完成了与对象 A 的复制过程。

就类对象⽽⾔,相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。

下⾯举例说明拷贝构造函数的⼯作过程。

[c-sharp]1. #include <iostream>2. using namespace std;3.4. class CExample {5. private:6. int a;7. public:8. //构造函数9. CExample(int b)10. { a = b;}11.12. //拷贝构造函数13. CExample(const CExample& C)14. {15. a = C.a;16. }17.18. //⼀般函数19. void Show ()20. {21. cout<<a<<endl;22. }23. };24.25. int main()26. {27. CExample A(100);28. CExample B = A; // CExample B(A); 也是⼀样的29. B.Show ();30. return 0;31. }CExample(const CExample& C) 就是我们⾃定义的拷贝构造函数。

carray的用法 -回复

carray的用法 -回复

carray的用法-回复CArray 是一个在C++标准模板库(STL)中定义的容器类。

它提供了一个动态数组的实现,可以用于存储和操作多个对象。

在这篇文章中,我们将深入探讨CArray 的用法和功能。

首先,让我们了解CArray 的基本信息。

CArray 是由最基本的数据类型或自定义类型组成的元素的集合。

与静态数组相比,CArray 具有动态调整大小的能力,这使得它成为处理灵活数量的对象的理想选择。

此外,CArray 还提供了一系列的成员函数来操作和管理元素。

要使用CArray,我们需要包含<array> 头文件,并使用`std` 命名空间。

接下来,我们可以声明和初始化一个CArray 对象,如下所示:cpp#include <iostream>#include <array>int main(){std::CArray<int, 5> myArray = {1, 2, 3, 4, 5};}在这个例子中,我们声明了一个CArray 对象`myArray`,它包含了5个整型元素,并初始化为1,2,3,4 和5。

现在,我们将详细介绍CArray 的一些常见用法。

1. 访问元素:使用索引操作符`[]` 可以访问CArrary 对象中的元素。

例如,要访问`myArray` 中的第一个元素,可以使用`myArray[0]`。

2. 插入元素:CArray 提供了几种方法来插入新元素。

`push_back()` 函数可以在CArray 的末尾添加一个新元素。

以下示例将向`myArray` 添加一个元素:cppmyArray.push_back(6);3. 删除元素:类似于插入操作,CArray 也提供了几种方法来删除元素。

`pop_back()` 函数删除CArray 的末尾元素。

以下示例将删除`myArray` 中的最后一个元素:cppmyArray.pop_back();4. 修改元素:可以使用索引操作符`[]` 直接修改CArray 对象中的元素。

C++ string类常用函数

C++ string类常用函数

C++ string类常用函数#include<string>using namespace std;构造函数:string(const char *s); //用c字符串s初始化string(int n, char c); //用n个字符c初始化此外,string类还支持默认构造函数和复制构造函数,如string s1;string s2="hello";都是正确的写法。

当构造的string太长而无法表达时会抛出length_error异常字符操作:const char &operator[](int n)const;const char &at(int n)const;char &operator[](int n);char &at(int n);注:operator[]和at()均返回当前字符串中第n个字符的位置,但at函数提供范围检查,当越界时会抛出out_of_range异常,下标运算符[]不提供检查访问。

const char *data()const; //返回一个非null终止的c字符数组const char *c_str()const; //返回一个以null终止的c字符串int copy(char *s, int n, int pos = 0) const; //把当前串中以pos开始的n个字符拷贝到以s为//起始位置的字符数组中,返回实际拷贝的数目特性描述:int capacity()const; //返回当前容量(即string中不必增加内存即可存放的元素个数)int max_size()const; //返回string对象中可存放的最大字符串的长度int size()const; //返回当前字符串的大小int length()const; //返回当前字符串的长度bool empty()const; //当前字符串是否为空void resize(int len,char c); //把字符串当前大小置为len,并用字符c填充不足的部分输入输出操作:string类重载运算符operator>>用于输入,同样重载运算符operator<<用于输出操作。

C试题及答案

C试题及答案

C++程序设计模拟试卷(五)一、单项选择题(本大题共20小题,每小题1分,共20分)在每小题列出的四个备选项中只有一个是符合题目要求的,请将其代码填写在题后的括号内。

错选、多选或未选均无分。

1.静态成员函数没有()A.返回值B.this指针C.指针参数D.返回类型答案:B解析:静态成员函数是普通的函数前加入static,它具有函数的所有的特征:返回类型、形参,所以使用静态成员函数,指针可以作为形参,也具有返回值。

静态成员是类具有的属性,不是对象的特征,而this表示的是隐藏的对象的指针,因此静态成员函数没有this指针。

静态成员函数当在类外定义时,要注意不能使用static关键字作为前缀。

由于静态成员函数在类中只有一个拷贝(副本),因此它访问对象的成员时要受到一些限制:静态成员函数可以直接访问类中说明的静态成员,但不能直接访问类中说明的非静态成员;若要访问非静态成员时,必须通过参数传递的方式得到相应的对象,再通过对象来访问。

2.在类的定义中,用于为对象分配内存空间,对类的数据成员进行初始化并执行其他内部管理操作的函数是()A.友元函数B.虚函数C.构造函数D.析构函数答案:C解析:定义构造函数作用就是初始化对象,而析构函数释放对象空间。

虚函数用于完成多态性,友元增加访问方便性。

3.所有在函数中定义的变量,都是()A.全局变量B.局部变量C.静态变量D.寄存器变量答案:B解析:变量存储类可分为两类:全局变量和局部变量。

(1)全局变量:在函数外部定义的变量称为全局变量,其作用域为:从定义变量的位置开始到源程序结束。

全局变量增加了函数之间数据联系的渠道,全局变量作用域内的函数,均可使用、修改该全局变量的值,但是使用全局变量降低了程序的可理解性,软件工程学提倡尽量避免使用全局变量。

(2)局部变量:在函数内部定义的变量称为局部变量,其作用域为:从定义变量的位置开始到函数结束。

局部变量包含自动变量(auto)静态变量(static)以及函数参数。

C++中的string常用函数用法总结

C++中的string常用函数用法总结

C++中的string常用函数用法总结首先,为了在我们的程序中使用string类型,我们必须包含头文件<string>。

如下:#include <string> //注意这里不是string.h string.h是C字符串头文件#include <string>using namespace std;1.声明一个C++字符串声明一个字符串变量很简单:string Str;这样我们就声明了一个字符串变量,但既然是一个类,就有构造函数和析构函数。

上面的声明没有传入参数,所以就直接使用了string的默认的构造函数,这个函数所作的就是把Str 初始化为一个空字符串。

String类的构造函数和析构函数如下:a) string s; //生成一个空字符串sb) string s(str) //拷贝构造函数生成str的复制品c) string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值d) string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多st rlen”的部分作为字符串的初值e) string s(cstr) //将C字符串作为s的初值f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。

g) string s(num,c) //生成一个字符串,包含num个c字符h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值i) s.~string() //销毁所有字符,释放内存都很简单,我就不解释了。

2.字符串操作函数这里是C++字符串的重点,我先把各种操作函数罗列出来,不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数,再到后面看他的详细解释。

a) =,assign() //赋以新值b) swap() //交换两个字符串的内容c) +=,append(),push_back() //在尾部添加字符d) insert() //插入字符e) erase() //删除字符f) clear() //删除全部字符g) replace() //替换字符h) + //串联字符串i) ==,!=,<,<=,>,>=,compare() //比较字符串j) size(),length() //返回字符数量k) max_size() //返回字符的可能最大个数l) empty() //判断字符串是否为空m) capacity() //返回重新分配之前的字符容量n) reserve() //保留一定量内存以容纳一定数量的字符o) [ ], at() //存取单一字符p) >>,getline() //从stream读取某值q) << //将谋值写入streamr) copy() //将某值赋值为一个C_strings) c_str() //将内容以C_string返回t) data() //将内容以字符数组形式返回u) substr() //返回某个子字符串v)查找函数w)begin() end() //提供类似STL的迭代器支持x) rbegin() rend() //逆向迭代器y) get_allocator() //返回配置器下面详细介绍:2.1 C++字符串和C字符串的转换C ++提供的由C++字符串得到对应的C_string的方法是使用data()、c_str()和copy(),其中,data()以字符数组的形式返回字符串内容,但并不添加'/0'。

C++试题

C++试题

判断题1构造函数、析构函数、友元函数都属于类的成员函数。

2静态数据成员是类的所有对象共享的数据。

3 可以将派生类的对象的值赋给基类对象,也可以将基类对象的值赋给派生类对象。

4 派生类默认的继承方式为public。

5 类模板实例化的过程是类模板->模板类->对象。

6 多继承情况下,派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。

7 构造函数可以重载,析构函数也可以重载。

8 如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相同,那么,这个函数自动继承基类中虚函数的特性。

9 设A为类,则A类的复制构造函数原型声明为void A(A&)。

10 在公有继承中,基类中只有公有成员对派生类是可见的。

11 在公有继承中,基类的公有成员和私有成员在派生类中都是可见的。

12 虚基类是用来解决多继承中公共基类在派生类中只产生一个基类子对象的问题。

13 派生类是从基类派生出来,他不能生成新的派生类。

14 当一个对象调用成员函数时,编译程序先将对象的地址赋值给this指针后,再调用成员函数。

15 对象是属性和行为的集合。

16 模板的使用是为了加强类的封装性。

17 函数定义时在函数参数表后加=0表示该函数为纯虚函数。

18 可以以”类名::静态成员函数(实参表)”和“对象.静态成员函数(形参表)”两种形式调用类的静态成员函数。

19 语句Int a(5),*p; *p=a;能够正常执行。

20 设A为类,则A *(*fpA[5])()的正确描述是:fpA是一个数组,数组的5个元素都是A类对象。

21 重载双目运算符为成员函数时,一般将左操作数作为函数的参数。

22 可以将插入运算符“ <<”和提取运算符“ >> ”重载为类的成员函数。

23 C++语言中,即允许单继承,又允许多继承。

24 派生类的继承方式有两种:公有继承和私有继承。

25 在私有继承中,基类中所有成员对派生类的对象都是不可见的。

C++中构造函数作用

C++中构造函数作用

C++中构造函数作⽤⼀、 构造函数是⼲什么的该类对象被创建时,编译系统对象分配内存空间,并⾃动调⽤该构造函数->由构造函数完成成员的初始化⼯作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_imag = c.m_imag;}// 类型转换构造函数,根据⼀个指定的类型的对象创建⼀个本类的对象,//需要注意的⼀点是,这个其实就是⼀般的构造函数,但是对于出现这种单参数的构造函数,C++会默认将参数对应的类型转换为该类类型,有时候这种隐私的转换是我们所不想要的,所以需要使⽤explicit来限制这种转换。

c++复习题及答案

c++复习题及答案

1、填空题()多态分为:专用多态和通用多态。

2、选择题(10分)下面对构造函数的描述不正确的是(C )A 可以重载B 其名字与类名相同C 可以显式调用构造函数D 构造函数是成员函数E 构造函数不能是虚函数3、判断题(正确的请写T,错误的请写F)(20分)静态成员函数可以直接调用类中说明的非静态成员。

(F)windows应用程序采用基于消息的事件驱动运行机制。

(T)(一)填空题在类体内使用关键字(static )说明的成员称为静态成员。

2、重载的函数要求参数的(个数)和(类型)不同。

3、如果要表示某个变量的值不能修改,用修饰符(const )限制。

4、对函数int fun( int x,int y) 中的参数x指定默认值10 正确的声明方式是(int fun(int y,int x=10) )。

5、C++语言规定,成员函数如果被定义在类体内,则为默认为(内联成员函数)。

6、在类层次结构中,创建子类对象时,(派生类)构造函数最后被执行。

7、C++规定,运行多态性通过(基)类的指针或者(引用)调用(虚函数)来实现。

8、派生类的生成过程经历了三个步骤:(吸收基类成员)、(改造基类成员)和(添加新的成员)。

9、面向对象程序设计的4个基本特征是(抽象)、(继承)、(封装)、(多态)。

10、Windows应用程序采用基于(消息)的事件驱动运行机制。

11、通常将用来派生新类的类称为(基类),又称为父类,而将派生出来的新类称为(派生类),又称为子类。

12、含有(纯虚)函数的类称为抽象类。

13、引用与被引用的实体具有相同的(地址)。

14、类成员的访问权限有3种(共有类型)、(私有类型)、(保护类型)。

15、通过函数改变实参的数据,c++ 可以通过( 指针)或者(引用)实现。

16、c++通过(函数重载)实现静态多态性,其(形参个数或类型)必须不同。

18、c++类的用途有两种,一种是生成类的对象,另一种是通过(继承)派生出新类。

C++试题及答案 (五)

C++试题及答案 (五)

C++程序设计模拟试卷(五)一、单项选择题(本大题共20小题,每小题1分,共20分)在每小题列出的四个备选项中只有一个是符合题目要求的,请将其代码填写在题后的括号内。

错选、多选或未选均无分。

1。

静态成员函数没有()A。

返回值B. this指针C. 指针参数D。

返回类型答案:B解析:静态成员函数是普通的函数前加入static,它具有函数的所有的特征:返回类型、形参,所以使用静态成员函数,指针可以作为形参,也具有返回值。

静态成员是类具有的属性,不是对象的特征,而this表示的是隐藏的对象的指针,因此静态成员函数没有this 指针。

静态成员函数当在类外定义时,要注意不能使用static关键字作为前缀.由于静态成员函数在类中只有一个拷贝(副本),因此它访问对象的成员时要受到一些限制:静态成员函数可以直接访问类中说明的静态成员,但不能直接访问类中说明的非静态成员;若要访问非静态成员时,必须通过参数传递的方式得到相应的对象,再通过对象来访问.2. 在类的定义中,用于为对象分配内存空间,对类的数据成员进行初始化并执行其他内部管理操作的函数是()A. 友元函数B。

虚函数C. 构造函数D. 析构函数答案:C解析:定义构造函数作用就是初始化对象,而析构函数释放对象空间。

虚函数用于完成多态性,友元增加访问方便性。

3。

所有在函数中定义的变量,都是()A. 全局变量B. 局部变量C。

静态变量D. 寄存器变量答案:B解析:变量存储类可分为两类:全局变量和局部变量.(1)全局变量:在函数外部定义的变量称为全局变量,其作用域为:从定义变量的位置开始到源程序结束。

全局变量增加了函数之间数据联系的渠道,全局变量作用域内的函数,均可使用、修改该全局变量的值,但是使用全局变量降低了程序的可理解性,软件工程学提倡尽量避免使用全局变量。

(2)局部变量:在函数内部定义的变量称为局部变量,其作用域为:从定义变量的位置开始到函数结束。

局部变量包含自动变量(auto)静态变量(static)以及函数参数.auto变量意味着变量的存储空间的分配与释放是自动进行的.说明符auto可以省略。

C++知识点总结

C++知识点总结

类和对象初步1.类的定义在定义外成员函数的实现2.类的成员函数之间可以相互调用,类的成员函数也可以重载,也可设默认参数值3.一般来讲,一个对象占用的内存空间的大小等于其成员变量的体积之和。

每个对象都有自己的存储空间(成员变量),但成员函数只有一份对象名.成员名指针->成员名引用名.成员名4.private:一个类的私有成员,只能在该类的成员函数中才能访问public:proteced:5.class默认private struct默认public6.内联成员函数:成员函数名前加inline 或函数体写在类定义内部的成员函数。

执行更快,但会带来额外的内存开销构造函数1.构造函数全局变量在堆上,系统自动初始化为零。

局部变量在栈上,初始值是随机的,需要初始化。

2.构造函数:对对象进行初始化。

构造函数执行时对象的内存空间已经分配,构造函数的作用是初始化这片空间.可重载,不写的话有默认构造函数,但是如果编写了构造函数,那默认构造函数不会再执行.是一类特殊的成员函数。

不写返回值类型,函数名为类名.3.对象在生成时一定会调用某个构造函数,一旦生成,不再执行构造函数.4.P183 Ctest *pArray[3]={new Ctest(4),new Ctest(1,2)}5.复制构造函数:其是构造函数的一种,只有一个参数,为本类的引用,防止混淆,构造函数不能以本类的对象作为唯一的参数。

默认复制构造函数。

6.复制构造函数被调用的三种情形:1用一个对象去初始化另一个对象时Complex C1(C2)ComplexC2=C1; 2 函数的参数是类A的对象。

形参未必等于实参函数中用对象的引用不会调用复制构造函数void Function(const Complex &c)3 函数的返回值是类A的对象7.类型转换构造函数:除复制构造函数外,只有一个参数的构造函数C=68.析构函数:在对象消亡时调用,可以定义其做善后工作。

c++ string的构造函数

c++ string的构造函数

c++ string的构造函数
C++标准库中的string类提供了多个构造函数,用于创建和初始化字符串对象。

以下是几种常见的构造函数:
1. 默认构造函数
```c++
string();
```
该构造函数创建一个空的字符串对象。

2. 带有字符个数 n 和初始化字符 c 的构造函数
```c++
string(size_t n, char c);
```
该构造函数创建一个由n个字符c组成的字符串对象。

3. 复制构造函数
```c++
string(const string& str);
```
该构造函数通过复制另一个字符串对象来创建一个新的字符串对象。

4. 带有C风格字符串参数的构造函数
```c++
string(const char* s);
```
该构造函数使用一个以null结尾的C风格字符串s来创建一个新的字符串对象。

5. 带有指定长度的C风格字符串参数的构造函数
```c++
string(const char* s, size_t n);
```
该构造函数使用一个指定长度n的C风格字符串s来创建一个新的字符串对象。

C++程序设计练习题及答案第五章类与对象

C++程序设计练习题及答案第五章类与对象

第5章类与对象5.1 选择题1. 在下列结构变量的定义中,不正确的是( d )。

(a) struct employee{ char name[ 20 ] ;long code ;} emp ;(b) struct{ char name[ 20 ] ;long code ;} emp ;(c) struct employee{ char name[20];long code;} ;employee emp;(d) struct{ char name[20];long code;} employee;employee emp;2.已知有职工情况结构变量emp定义为:struct employee{ char name[ 20 ] ;long code ;struct{ int year ;int month ;int day ;} birth ;} emp ;下列对 emp 的 birth 正确赋值方法是( d )。

(a) year = 1980 ; month = 5 ; day = 1 ;(b) birth.year = 1980 ; birth.month = 5 ; birth.day = 1 ;(c) emp.year = 1980 ; emp.month = 5 ; emp.day = 1 ;(d) emp.birth.year = 1980 ; emp.birth.month = 5 ; emp.birth.day= 1 ;3.假定有以下声明和定义,则下面引用形式错误的是( b )。

1struct student{ int num ;float score ;} stu[3] = {{1001,80},{1002,75},{1003,91}}, *p = stu ; (a) p->num (b) (p++).num (c) (p++)->num (d) (*p).num4.下列四个运算符中,优先级最低的是( a )。

C++考试题(选择题)

C++考试题(选择题)

C++考试题(选择题)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、ifstreamB、ostreamC、fstreamD、ofstream8、对于派生类的构造函数,在定义对象时构造函数的执行顺序为:先执行__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___文件。

C++期末复习(程序填空题)1

C++期末复习(程序填空题)1
{ a=x; b=y; c=z; }
float area()
{ float t,s;
t=(a+b+c)/2;
s=sqrt(t*(t-a)*(t-b)*(t-c));
return s; }
};
class rectangle:public shape
{
float a,b;
};
答:new int(aa) 、delete a
2、下面是一个函数模板,用于计算两个向量的和。在下面横线处填上适当字句,完成函数模板定义。
# include <iostream.h>
template<class T>
T* f(T* a,T* b,int n)
{
T* c=_________;
if (x>z) { a=x; x=z; z=a; }
if (y>z) { a=y; y=z; z=a; }
cout <<x<<"\t"<<y<<"\t"<<z<<endl;
}
void main()
{ sort(2.4,15.7,1.2);
sort(20,15,-82);
sort('A','Y','9');
friend int samecolor(line a,box b);
void set _color(int c) {color=c;}
void define _box(int x1,int y1,int x2,int y2)

C面向对象程序设计重点复习

C面向对象程序设计重点复习

面向对象程序设计复习题一、单项选择题1.下面关于对象概念的描述中,_______是错误的;BA.对象代表着正在创建的系统中的一个实体B.对象就是C语言中的结构体变量C.对象是一个状态和操作或方法的封装体D.对象之间的信息传递是通过消息进行的2. 继承机制的作用是: CA.信息隐藏B.数据封装C.定义新类D.数据抽象3.有关析构函数的说法不正确的是_________DA.析构函数有且只有一个B.析构函数无任何函数类型C.析构函数没有形参D.析构函数不能是虚函数4.友元的作用之一是__________AA.提高程序的运行效率B.加强类的封装性C.实现数据的隐藏性D.增加成员函数的种类5.通常拷贝构造函数的参数是__________;CA.某个对象名B.某个对象的成员名C.某个对象的引用名D.某个对象的指针名6.如果在基类中将show声明为不带返回值的纯虚函数,正确的写法是________;Cshow=0; void show;void show=0; show=0 virtual;7.下面关于友元的描述中,错误的是_________;DA.友元函数可以访问该类的私有数据成员B.一个类的友元类中的成员函数都是这个类的友元函数C.友元可以提高程序的运行效率D.类与类之间的友元关系可以继承8.在C++中,_________运算符不能重载;BA. +B.: D.<=9.下列关于运算符重载的描述中,________是正确的;DA.运算符重载可以改变操作数的个数B.运算符重载可以改变优先级C.运算符重载可以改变结合性D.运算符重载不可以改变语法结构10. 在下列函数原型中,可以作为类AA构造函数的是_________DA.void AAint ; B.int AA ; C.AAintconst; D.AAint;11.在声明类时,下面的说法正确的是_________;CA.可以在类的声明中给数据成员赋初值B.数据成员的数据类型可以是register,public,protected可以按任意顺序出现D.没有用private,public,protected定义的数据成员是公有成员12.继承具有________,即当基类本身也是某一个类的派生类时,底层的派生类也会自动继承间接基类的成员;BA.规律性B.传递性C.重复性D.多样性13.在多重继承中,公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则___________;AA.完全相同B.完全不同C.部分相同,部分不同D.以上都不对14.对虚函数的调用__________;DA.一定使用动态联编B.必须使用动态联编C.一定使用静态联编D.不一定使用动态联编15.关于成员函数特征的下述描述中,_______是错误的;AA.成员函数一定是内置函数B.成员函数可以重载C.成员函数可以设置参数的默认值D.成员函数可以是静态的16. 下面关于c++语言变量的叙述错误的是_______BA.在c++语言中变量分为auto,static,extern和register四种存储类型B.自动变量和外部变量的作用域为整个程序C.内部变量的作用域是定义它的函数D.外部静态变量的作用域是定义它的文件17.下列的各类函数中,_______不是类的成员函数;CA.构造函数B.析构函数C.友元函数D.拷贝构造函数18. 有如下类声明:class Foo {ing bar ;};则Foo类的成员bar是_________CA.公有数据成员B.公有成员函数C.私有数据成员D.私有成员函数19.下列表示引用的方法中,__________是正确的;已知:int m=10; DA. float &t=&m; &y=10; &z; D. int &x=m;20.设置虚基类的目的是________;BA.简化程序B.消除二义性C.提高运行效率D.减少目标代码21.对于类中定义的成员,其隐含访问权限为________B22.关于类和对象不正确的说法是________ BA.类是一种类型,它封装了数据和操作B.一个类的对象只有一个C.对象是类的实例D.一个对象必属于某个类23.声明一个类的对象时,系统自动调用一个函数___c___;撤消对象时,系统自动调用一个函数;该函数为___c___A.成员函数;构造函数B.复制构造函数;析构函数C.构造函数;析构函数D.析构函数;复制构造函数24.当一个派生类私有继承一个基类时,基类中的所有公有成员和保护成员成为派生类的__A______ 成员成员成员 D.友元25.在C++中,要实现动态联编,必须使用_____D___调用虚函数A.类名B.派生类指针C.对象名D.基类指针26.若一个类中含有纯虚函数,则该类称为____A____A. 抽象类B. 纯基类C.派生类D. 基类27.下列关于this指针的叙述中,正确的是___D_____A.任何与类相关的函数都有this指针B.类的成员函数都有this指针C.类的友元函数都有this指针D.类的非静态成员函数才有this指针28.有如下类声明:class Book {int num ;};则Book类的成员num是___D_____A.公有数据成员B.公有成员函数C.私有数据成员D.私有成员函数29.下面有关重载函数的说法中正确的是___C_____A.重载函数必须具有不同的返回值类型;B.重载函数形参个数必须不同;C重载函数必须有不同的形参列表; D.重载函数名可以不同;30.设置虚基类的目的是___A_____A.消除二义性B.简化代码C.提高运行效率D.减少目标代码31.在C++语言程序中,对象之间的相互通信通过___B_____A.继承实现B.调用成员函数实现C.封装实现D.函数重载实现32.下列运算符中,在C++语言中不能重载的是__C______A. B.>= C.:: D./33.下面对友元函数描述正确的是___C_____A.友元函数的实现必须在类的内部定义B.友元函数是类的成员函数C.友元函数破坏了类的封装性和隐藏性D.友元函数不能访问类的私有成员34.下面叙述不正确的是___A_____A.基类的保护成员在派生类中仍然是保护成员B.基类的保护成员在公有派生类中仍然是保护成员C.基类的保护成员在私有派生类中是私有成员D.对基类成员的访问必须是无二义性35.下面对静态数据成员的描述中,正确的是___D_____A.静态数据成员可以在类体内进行初始化B.静态数据成员不可以被类的对象调用C.静态数据成员不能受private控制符的作用D.静态数据成员可以直接用类名调用36.在C++类语言体系中,不能被派生类继承的有_______BA.转换函数B.构造函数C.虚函数D.静态成员函数37.在类的定义中,用于为对象分配内存空间,对类的数据成员进行初始化并执行其他内部管理操作的函数是____C____A.友元函数B.虚函数C.构造函数D.析构函数38.下列关于虚基类的描述中,错误的是_B_______A.设置虚基类的目的是为了消除二义性;B.虚基类的构造函数在非虚基类之后调用;C.若同一层包含多个虚基类,这些基类的构造函数按照它们的次序调用;D.若虚基类由非基类派生而来,则仍然先调用基类构造函数,再用派生类的构造函数;39.考虑函数原型voidtestinta,int b=7,char="",下面的函数调用中,属于不合法调用的是___C_____A. test5 5,8 6,"" 0,0."";40.下列关于构造函数的描述中,错误的是___D_____A.构造函数可以设置默认参数;B.构造函数在定义类对象时自动执行C.构造函数可以是内联函数;D.构造函数不可以重载41.在重载一个运算符时,如果其参数表中有一个参数,则说明该运算符是 ; DA.一元成员运算符 B.二元成员运算符 C.一元友元运算符 D.选项B和选项C都可能42.在公有派生情况下,有关派生类对象和基类对象的关系,下列叙述不正确的是 ; CA.派生类的对象可以赋给基类的对象 B.派生类的对象可以初始化基类的引用C.派生类的对象可以直接访问基类中的成员 D.派生类的对象的地址可以赋给指向基类的指针43.下面关于虚函数的描述,错误的是 ; BA.在成员函数声明的前面加上virtual修饰,就可把该函数声明为虚函数B.基类中说明了虚函数后,派生类中对应的函数也必须说明为虚函数C.虚函数可以是另一个类的友元函数,但不能是静态成员函数D.基类中说明的纯虚函数在其任何派生类中都必须实现44.定义派生类时,若不使用关键字显示地规定采用何种继承方式,则默认方式为 ; AA.私有继承 B.非私有继承 C.保护继承 D.公有继承45.有如下程序:includeusing namespace std;class ONE{int c;public:ONE:c0{cout<<1;}ONEint n:cn{cout<<2;}};class TWO{ONE onel;ONE one2;public:TWOint m:one2m{cout<<3;}};int main{TWO t 4 ;return 0 ;}运行时的输出结果是 ; CA.3B.23C.123D.21346.关于静态数据成员的描述中正确的是DA类的静态数据成员不是类的所有对象共享的数据B类的静态数据成员不能被类的成员函数调用C类的静态数据成员不能被类的构造函数调用D类的静态数据成员必须进行初始化47下面正确的是,在父类中的访问属性访问修饰符在子类中的访问属性CApublic,private不能直接访问 Bprotect,public,publicCprivate,public不能直接访问 Dprotect,private,protect48类A是类B的友元,类B是类C的友元,则下列说法正确的是DA类B是类A的友元B类C是类A的友元C类A是类C的友元D以上都不对49下列关于构造函数说法不正确的是CA构造函数必须与类同名 B构造函数可以省略不写C构造函数必须有返回值 D在构造函数中可以对类中的成员进行初始化50.类的析构函数的作用是DA一般成员函数的初始化 B类的初始化C对象的初始化D删除类创建的对象51.下列说法正确的是BA内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方B内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方C类的内联函数必须在类体内定义D类的内联函数必须在类体外通过加关键字inline定义52.下面对静态数据成员的描述中,正确的是DA静态数据成员可以在类体内进行初始化B静态数据成员不可以被类的对象调用C静态数据成员不能受private控制符的作用D静态数据成员可以直接用类名调用二、知识点1.实现运行时的多态性要使用虚函数;2.如果一个类至少有一个纯虚函数,那么就称该类为抽象类;3. 运算符重载不能改变操作符的个数、运算符的优先级、运算符的结合性和运算符的语法结构;4. 构造函数是一种特殊的成员函数,它主要用来为对象分配内存空间,对类的数据成员进行初始化并执行对象的其他内部管理操作;5. 静态成员函数不能直接引用类中说明的非静态成员;6. 引用是给对象取一个别名,它引入了对象的同义词;7.设置友元函数的目的是为能够访问该类的私有成员;8.运算符重载仍然保持原来的优先级、结合性和语法结构;9.基类的私有成员不能被派生类的成员访问;10.静态联编支持的多态性称为编译时的多态性,也称静态多态性;11.任何类中允许有三种访问权限的数据,这三种访问权限分别是public、private、protected;12.为了满足运算符“+”的可交换性,必须将其重载为友元函数;13.对于含有对象成员的派生类,其构造函数的执行顺序为:先执行基类的构造函数、再执行对象成员的构造函数,后执行派生类的构造函数;14.利用成员函数对双目运算符重载,其左操作数为this指针指出的对象,右操作数为成员函数参数;++允许在相同的作用域内以相同的名字定义几个不同实现的函数,称这种同一个函数名多个含义的现象为函数重载;16.通过使用new和delete两个运算符进行的分配为动态存储分配;17.当类定义中有数据成员为指针时,解决浅拷贝出现的运行错误的方法是编写拷贝构造函数;18.如果使用protected继承基类,其公有成员就会变成派生类的保护成员,其保护成员就会变成派生类的保护成员,其私有成员不能继承19.一个函数功能不太复杂但要求被频繁调用,应定义为内联函数;20.抽象类只能作为基类使用,而不能声明它的对象;21.构造函数可以重载,析构函数不可以重载;22.静态成员函数没有this指针;23.类有两个特殊的成员函数构造函数和析构函数;24.在表达式x+yz中,+是作为成员函数重载的运算符,是作为非成员函数重载的运算符;其中operator+有一个参数,operator有两个参数;25.一个派生类只有一个基类的情况称为单继承,而有多个直接基类的情况称为多继承;26.调用析构函数的次序正好与调用构造函数的次序相反;27. 非成员函数应说明为类的友元函数才能访问这个类的private成员;28. 通过使用new和delete两个运算符进行的分配为动态存储分配;29.如果类B继承了类A,则称类A为类B的基类,类B称为类A的派生类30. 表达式operator+x,y还可以表示为x+y ;31 C++语言中的多态性分为编译时的多态性和运行时的多态性;32将x+yz中的"+"用成员函数重载,""用友元函数重载,应解释为x. operator+operatory,z33如果要把返回值为void的函数A声明为类B的友元函数,则应在类B的定义中加入的语句是friend void A ;34派生类的成员一般分为两部分,一部分是从基类继承的成员,另一部分是自己定义的新成员;35继承的方式有公有继承、私有继承和保护继承3种;。

C期末考试复习题理工

C期末考试复习题理工

一、单项选择题(本大题共10小题,每小题2分,共20分)1.在C++中,函数原型不能标识(D)A.函数的返回类型B.函数参数的个数C.函数参数类型D.函数的功能2.在C++程序中,对象之间的相互通信通过(B)A.继承实现B.调用成员函数实现C.封装实现D.函数重载实现3.对于任意一个类,析构函数的个数最多为(B)A.0B.1C.2D.35.友元关系不能(A)A.继承B.是类与类的关系C.是一个类的成员函数与另一个类的关系D.提高程序的运行效率6.语句ofstreamf(″SALARY.DAT″,ios::app|ios::binary)?的功能是建立流对象f,试图打开文件SALARY.DAT并与之连接,并且(A)A.若文件存在,将文件写指针定位于文件尾;若文件不存在,建立一个新文件B.若文件存在,将其置为空文件;若文件不存在,打开失败C.若文件存在,将文件写指针定位于文件首;若文件不存在,建立一个新文件D.若文件存在,打开失败;若文件不存在,建立一个新文件7.下面说法正确的是(B)A.内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方B.内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方C.类的内联函数必须在类体内定义D.类的内联函数必须在类体外通过加关键字inline定义//当程序使用内敛函数时,编译器将每个函数调用都用函数内的语句代替,这样就省去了函数调用地开销8.可以用p.a的形式访问派生类对象p的基类成员a,其中a是(D)A.私有继承的公有成员B.公有继承的私有成员C.公有继承的保护成员D.公有继承的公有成员//函数可以调用成员,对象不可以调用9.在公有派生情况下,有关派生类对象和基类对象的关系,不正确的叙述是(C)A.派生类的对象可以赋给基类的对象B.派生类的对象可以初始化基类的引用C.派生类的对象可以直接访问基类中的成员D.派生类的对象的地址可以赋给指向基类的指针//派生类的对象是不能访问基类的任何成员10.对于类定义classA{public:virtualvoidfunc1(){}voidfunc2(){}}?classB:publicA{public:voidfunc1(){cout<<″classBfunc1″<<end1?}virtualvoidfunc2(){cout<<″classBfunc2″<<end1?}}?下面正确的叙述是(C)A.A::func2()和B::func1()都是虚函数B.A::func2()和B::func1()都不是虚函数C.B::func1()是虚函数,而A::func2()不是虚函数D.B::func1()不是虚函数,而A::func2()是虚函数第二部分非选择题(共80分)二、填空题(本大题共10小题,每小题2分,共20分)11.定义类的动态对象数组时,系统只能够自动调用该类的_无参_______构造函数对其进行初始化。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

C++类的构造函数和复制构造函数
[日期:2011-03-11] 来源:LinuxLinux 作者:pcliuguangtao
首先,我们先看一个小小的问题:
#include <iostream>
#include <string>
using namespace std;
class C{
public:
C(){
cout<<"cccc"<<endl;
}
C( C& c){
m = c.m;
cout<<"copy constructor"<<endl;
}
string m;
};
int main() {
string x ="ssss";
C c2=C();
//报错:no matching function for call to 'C::C(C)'
return 0;
}
作者的问题有:
1、C c2=C() 为什么出错误?为什么构造函数要改成C(const C& c)?
2 、为什么调用无参构造函数时不能写成:C c(); ?
开始介绍关于类构造函数的知识点:
1、首先,类的构造函数是用来处理对像的初始化的,并且,构造函数是一种特殊的成员函数,与其他成员函数不同,不需要用户来(显式)的调用它,而是
在建立对象时自动执行。

那么怎样才叫显式的调用那?
比如已经有一个Student类
class Student
{
public:
Student(int num,int score ):
m_number( num ),m_score(score ){}
Studnet( ){} //默认构造函数
void PrintInfo( )
{
cout<<m_score<<" "<<m_number<<endl;
}
private:
int m_number;
int m_score;
};
Student stud_one.Student(123,96); //显式调用构造函数,编译器不允许
Student Stud_two(124,98); //正确的调用方式
Student stud_three;
stud_three.Student(125,99) ; //也是错误的,构造函数是在建立对象时有系统自动执行的,而且只执行一次。

2、默认构造函数:
建立一个对象时不需要给出实参的构造函数,叫该类的默认构造函数,又名缺省构造函数。

比如:
Student(){} // (如果我们没有自己定义一个默认构造函数,编译器默认添加该构造函数作为默认构造函数)、Student(int num=123,int score=60):m_number(num),m_score(score){} //一个构造函数给出了所有数据成员的默认值
一个类只能有一个默认构造函数(也可以说成,可以不使用参数而调用的构造函数,一个类只能有一个),否则,系统就无法辨别出默认的时候应该调用那个来构造一个新的对象!
3、复制和赋值
复制:一个新的对象用一个已存在的对象来初始化,如Student temp(stud_one); 或者Student temp=stud_one;
但要注意,使用复制的前提是你已经定义了该类的复制构造函数Student::Student(const Student& b )
(其中的const只是说明,在复制构造函数中不允许修改b对象的值!)
赋值:两个已存在的对象赋值,编译器已经给我们重载了“=”,所以我们不用自己再定义,比如stud_one=stud_two;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~
下面来分析开始给出的两个问题:
1、C c2=C();
这个语句没有调用复制构造函数,而只是调用了C类的构造函数,所以会输出“cccc”,而不是“copy constructor”;
我们需要加上const,是
因为G++是遵循了C++标准(2003)中的规定:非const引用不能绑定于临时对象。

加上一个const才能编译通过。

2、C c()编译器理解为定义一个函数c(),他的返回值为一个C 类的像。

相关文档
最新文档