c++题目详解一

c++题目详解一

小猿来了，c++经典易错题，呕心推荐
1、

#include<iostream>
using namespace std;
class Sample
{
public:
 Sample(int x)
 {
     p = new int(x);//填空
     //指针变量 = new 类型（常量）  常量是初始化值，可缺省
    //指针变量 = new 类型[表达式] 创建数组对象不能指定初始值
 }
 ~Sample()
 {
     if(p) delete p;//分配成功则释放
 }
 int show()
 {
     return *p;
 }
 private:
 int *p;
}；	
int main()
{
 Sample S(5);
 cout<<s.show()<<endl;
 return 0;

}

2、A,B,C为布尔类型，v和^分别表示布尔类型的或和与

A ^ (B v C)=(A ^ B) v (A ^ C)结合律

(B ^ A) v C=C v (A ^ B)交换律

3、class A *pclass = new class A[5];

​ delete pclass ;

c++中，类class A的构造函数和析构函数的执行次数
（5，1）

对于简单类型delete和delete[]都能释放分配的内存，但是delete只调用a[0]的析构函数（1次），delete[] (5次)

如果类中使用了操作系统的系统资源，（Socket、File、Thread），如果不调用对象的析构函数会导致系统资源不被释放。

4、在32位系统中，关于下面的程序说法正确的是（）

class Item
{
    char *desc;
    int storage;
public:
    Item()
    {
        desc = new char[51];
    }
    void seInfo(char *dsrc,int num)
    {
        strcpy(desc,dsrc);
        storage = num;
    }
}；
int main()
{
    Item stock;
    stock.setInfo("pen",20);
    return 0; 
}
ABC

A main函数定义了一个stock对象占8个字节；

B storage和desc成员各占4个字节；

C 存在内存泄漏问题；//析构函数中没有delete

D 存在编译错误；

//空类占1字节，一旦类中有其他的占用空间的成员，则这个字节就不在计算之内

//类函数不占用空间

//虚函数因为存在一个虚函数表，需要4个字节，遵循字节对齐

//static成员变量是存储在静态区，所以无需为其分配空间，计算对象的大小时要排除static成员变量

ps:友元函数不属于类但是可以访问类的私有成员或者是保护成员。但是与面向对象的程序设计思想相悖，建议仅在重载操作符的时候使用。

5、

#include <iostream>
using namespace std;
class MyClass
{
public:
    MyClass(int i = 0)
    {
        cout << i<<"猪";
    }
    MyClass(const MyClass& x)
    {
        cout << 2;
    }
    MyClass& operator=(const MyClass& x)
    {
        cout << 3;
        return *this;
    }
    ~MyClass()
    {
        cout << 4;
    }
};
int main()
{
    MyClass obj1(1),obj2(2);
    MyClass obj3 = obj1;
    obj1=obj2;
    return 0;
         
    
    //（1）定义一个对象时，以本类另一个对象作为初始值，调用复制构造函数；

    ------用一个对象去初始化另一个对象；
	Myclass obj1;
	Myclass obj2 = obj1;
    //（2）如果函数的形参是类的对象，调用函数时，将使用实参对象初始化形参对象时，调用复制构造函数；
     ------一个对象以值传递的方式进入函数体（一定要是值传递才会调用复制构造函数）；
	void Myclass::func(Myclass M);
     //（3）如果函数的返回值是类的对象，函数执行完成后返回主调函数时，将使用return语句中的对象初始化一个临时无名对象传递给主调函数，此时调用复制构造函数。
     ------一个对象以值传递的方式从函数体返回；
	Myclass fund();

重点在初始化

输出:1猪 2猪 2 3 4 4 4

//obj1对象传递给构造函数的参数是1，所以输出1猪,obj2对象传递给构造函数的参数是2，所以输出2猪

//重点看obj3，首先我们明确一点obj3这个对象以前不存在，那么这个地方调用的就是复制构造函数，满足其中（以一个对象去初始化另一个对象）

//obj1=obj2,因为obj1已经存在过，所以此处重载了=号操作符。只有3个对象，所以是3次析构

6、关于类的成员函数，错误的是C

A一般来说，一个类的成员函数对该类中的数据成员进行读写计算。

B如果一个数据成员希望是只读的，那么该成员因说明为私有，而且有一个公有的getXXx来读取它的值。

C一个类中的一组成员函数不能重名。//函数重载

D公有成员函数不应返回本类中私有成员的指针或引用

7、下面函数调用错的是：f1(0)

class A 
{
    int_a;
public:
    A(int a) :_a(a);
    {

    }
    friend int f1(A&);
    friend int f2(const A&);//保证不改变A的值，语法能通过，左值引用只能绑定左值
    friend int f3(A);
    friend int f4(const A);
};

8、关于一个类静态成员的描述，不正确的是D

A该类的对象共享其静态成员变量的值

B静态成员变量可被该类的所有方法访问

C该类的静态方法能访问该类的静态成员变量

D该类的静态成员变量的值不可修改//const

9、c++中，关于new的运算符的错误的描述是CD

A运算符new可以用来动态创建对象和对象数组

B使用运算符new创建对象时，会调用类的构造函数

C使用new运算符创建的对象使用完后会自动销毁并回收//需要调用delete

D使用运算符new创建对象数组时必须定义初始值//数组无法定义初始值

10、下列运算符重载函数中，属于友元函数的是

A Base operator+(Base);

B Base operator - -(Base);//友元函数无this指针

C Base operator &&(Base,Base);

D Base operator++(Base,int);//int为后++，区分前++

//运算符重载为成员函数，第一个参数必须是本类的对象。而<<和>>的第一个操作数一定是ostream类型，所以<<只能重载为友元函数。

//友元运算符重载函数没有 this 指针，所以不能引用 this 指针所指的对象，使用友元函数重载自增运算符“++”或自减运算符“- -”时，应采用对象引用参数传递数据。 例如：

friend Three operator++(Three &); //前缀方式
friend Three operator++(Three &,int); //后缀方式

@@@单目运算符、sizeof、条件运算符？：、赋值运算符结合性从右到左

11、那种情况会调用拷贝构造函数ACD

A用派生类的对象去初始化基类的对象时

B将类的一个对象赋值给该类的另一个对象//调用赋值重载operator=

C函数的形参是类的对象，调用函数进行形参和实参结合时

D函数的返回值是类的对象，函数执行返回调用时

12、以下程序输出为*a=10,p=20

int main()
{
    const int a = 10;
    int* p = (int*)(&a);
    *p = 20;//改变临时变量（临时空间）
    //C语言中都会改变
    cout << "a=" << a << "，*p=" << *p << endl;
}

13如果有一个类是MYClass,关于以下代码正确描述的是：C

MYClass::MYClass()
{
    delete this;//在成员函数中调用delete this，会导致指针错误，而在析构函数中调用delete this，出导致死循环，造成堆栈溢出。
    this = NULL;//const*this,段错误
}

A正确，我们避免了内存泄漏

B它会导致栈溢出

C无法编译通过

D这是不正确的，它没有释放任何成员变量

static修饰的成员变量和成员函数没有this指针。

14、输出B

class Base 
{
private:
    int a, b;//先定义a,b 未赋值会先给一个初始值（随机值）
public:
    Base(int i) :b(i + 1), a(b) {}//初始化成员列表
    Base() :b(0), a(b) {}
    int get_a() 
    { 
        return a;
    }
    int get_b()
    {
        return b;
    }
};
int main()
{
    Base obj1(11);
    cout << obj1.get_a() << endl << obj1.get_b() << endl;
}

A12 12 B随机数 12

C随机数 随机数 D12 随机数

15、以下代码那一句可能导致编译错误D

class Test
{
public:
    Test() { cout << "I like lsy"; }
    Test(int) { cout << "I like zjc"; }
    void exe() { cout << "this is my choice"; }
};
int main()
{
    Test a(1);//1
    a.exe();//2
    Test b();//3是函数声明
    b.exe();//4
    Test c;//5
    c.exe();//6
    return 0;
}

A1 B2 C3

D4 E5 F6

16、c++空类中默认产生哪些类成员函数（ABCD）

A默认构造函数

B析构函数

C拷贝构造函数

D赋值函数

//取址函数，const修饰的取址函数

17、设有ABCD4个类定义，程序中ABCD析构函数的调用顺序为

A B D C

C c//全局变量最后析构
void main()
{
    A *pa = new A();
    B b;
    static D d;
    delete pa;
}

持续更新中