题目
- 以下程序的运行结果是( )
cpp
#include <stdio.h>
int main(void) {
printf("%s , %5.3s\n", "computer", "computer");
return 0;
}
A. computer , puter
B. computer , com
C. computer , computer
D. computer , compu.ter
- 在32位cpu上选择缺省对齐的情况下,有如下结构体定义:
cpp
struct A{
unsigned a : 19;
unsigned b : 11;
unsigned c : 4;
unsigned d : 29;
char index;
};
则sizeof(struct A)
的值为( )
A. 9
B. 12
C. 16
D. 20
-
32位系统中,定义**a[3][4],则变量占用内存空间为( )。
A. 4
B. 48
C. 192
D. 12
-
假设在一个 32 位 little endian 的机器上运行下面的程序,结果是多少?
cpp
#include <stdio.h>
int main(){
long long a = 1, b = 2, c = 3;
printf("%d %d %d\n", a, b, c);
return 0;
}
A.1,2,3
B.1,0,2
C.1,3,2
D.3,2,1
- 有以下程序,程序运行后的输出结果是( )
cpp
#include<iostream>
#include<cstdio>
using namespace std;
int main(){
int m=0123, n=123;
printf("%o %o\n", m, n);
return 0;
}
A. 0123 0173
B. 0123 173
C. 123 173
D. 173 173
-
定义char dog[]="wang\0miao";那么sizeof(dog)与strlen(dog)分别是多少( )
A. 10,4
B. 4,4
C. 9,9
D. 9,4
-
下面两个结构体,在#pragma pack(4)和#pragma pack(8)的情况下,结构体的大小分别是( )
cpp
struct One{
double d;
char c;
int i;
}
struct Two{
char c;
double d;
int i;
}
A. 16 24,16 24
B. 16 20,16 20
C. 16 16,16 24
D. 16 16,24 24
- 有一个类A,其数据成员如下:
cpp
class A {
...
private:
int a;
public:
const int b;
float* &c;
static const char* d;
static double* e;
};
则构造函数中,成员变量一定要通过初始化列表来初始化的是( )
A. a b c
B. b c
C. b c d e
D. b c d
E. b
F. c
- C++ 中,有如下类模板定义:
cpp
template<class T>
class BigNumber{
long n;
public:
BigNumber(T i) :n(i) {}
BigNumber operator+(BigNumber b) {
return BigNumber(n + b.n);
}
};
已知 b1, b2 是 BigNumber 的两个对象,则下列表达式中错误的是( )
A. 3+3
B. b1+3
C. b1+b2
D. 3+b1
-
关于引用以下说法错误的是( )
A. 引用必须初始化,指针不必
B. 引用初始化以后不能被改变,指针可以改变所指的对象
C. 不存在指向空值的引用,但是存在指向空值的指针
D. 一个引用可以看作是某个变量的一个"别名"
E. 引用传值,指针传地址
F. 函数参数可以声明为引用或指针类型
-
以下代码共调用多少次拷贝构造函数:( )
cpp
Widget f(Widget u)
{
Widget v(u);
Widget w=v;
return w;
}
main(){
Widget x;
Widget y=f(f(x));
}
A. 1
B. 3
C. 5
D. 7
-
在重载一个运算符为成员函数时,其参数表中没有任何参数,这说明该运算符是 ( )
A. 无操作数的运算符
B. 二元运算符
C. 前缀一元运算符
D. 后缀一元运算符
-
在C++中,为了让某个类只能通过new来创建(即如果直接创建对象,编译器将报错),应该( )
A. 将构造函数设为私有
B. 将析构函数设为私有
C. 将构造函数和析构函数均设为私有
D. 没有办法能做到
-
print()函数是一个类的常成员函数,它无返回值,下列表示中正确的是( )
A. const void print();
B. void const print();
C. void print() const;
D. void print(const);
-
如果MyClass为一个类,执行"MyClass a[5], *b[6]"语言会自动调用该类构造函数的次数是( )
A. 2
B. 5
C. 4
D. 9
-
以下程序输出是( )
cpp
#include <iostream>
using namespace std;
int main(void)
{
const int a = 10;
int * p = (int *)(&a);
*p = 20;
cout<<"a = "<<a<<", *p = "<<*p<<endl;
return 0;
}
A. 编译阶段报错运行阶段报错
B. a = 10, *p = 10
C. a = 20, *p = 20
D. a = 10, *p = 20
E. a = 20, *p = 10
- 如果有一个类是 myClass , 关于下面代码正确描述的是 ( )
cpp
myClass::~myClass(){
delete this;
this = NULL;
}
A. 正确,我们避免了内存泄漏
B. 它会导致栈溢出
C. 无法编译通过
D. 这是不正确的,它没有释放任何成员变量。
-
请问以下说法,哪个是正确的 ( )
A. 每个类都有一个无参数的构造函数。
B. 每个类都有一个拷贝构造的函数。
C. 每个类能有多个构造函数。
D. 每个类能有多个析构函数。
-
C++中关于堆和栈的说法,哪个是错误的 ( )
A. 堆的大小仅受操作系统的限制,栈的大小一般较小
B. 在堆上频繁的调用new/delete容易产生内存碎片,栈没有这个问题
C. 堆和栈都可以静态分配
D. 堆和栈都可以动态分配
-
C++将父类的析构函数定义为虚函数,下列正确的是哪个( )
A. 释放父类指针时能正确释放子类对象
B. 释放子类指针时能正确释放父类对象
C. 这样做是错误的
D. 以上全错
-
分析一下这段程序的输出( )
cpp
#include<iostream>
using namespace std;
class B
{
public:
B()
{
cout << "default constructor" << " ";
}
~B()
{
cout << "destructed" << " ";
}
B(int i): data(i)
{
cout << "constructed by parameter" << data << " ";
}
private: int data;
};
B Play( B b)
{
return b;
}
int main(int argc, char *argv[])
{
B temp = Play(5);
return 0;
}
A. constructed by parameter5 destructed destructed
B. constructed by parameter5 destructed
C. default constructor" constructed by parameter5 destructed
D. default constructor" constructed by parameter5 destructed destructed
- 有一个类B继承自类A,他们数据成员如下:
cpp
class A {
...
private:
int a;
};
class B : public A {
...
private:
int a;
public:
const int b;
A &c;
static const char* d;
B* e;
}
则构造函数中,成员变量一定要通过初始化列表来初始化的是( )
A. a b c
B. b c e
C. b c d e
D. c e
E. b d
F. b c
- 以下程序的输出是( )
cpp
class Base {
public:
Base(int j): i(j) {}
virtual~Base() {}
void func1() {
i *= 10;
func2();
}
int getValue() {
return i;
}
protected:
virtual void func2() {
i++;
}
protected:
int i;
};
class Child: public Base {
public:
Child(int j): Base(j) {}
void func1() {
i *= 100;
func2();
}
protected:
void func2() {
i += 2;
}
};
int main() {
Base * pb = new Child(1);
pb->func1();
cout << pb->getValue() << endl; delete pb;
}
A. 11
B. 101
C. 12
D. 102
- 有如下C++代码:
cpp
struct A{
void foo(){printf("foo");}
virtual void bar(){printf("bar");}
A(){bar();}
};
struct B:A{
void foo(){printf("b_foo");}
void bar(){printf("b_bar");}
};
那么
cpp
A *p = new B;
p->foo();
p->bar();
输出为( )
A. barfoob_bar
B. foobarb_bar
C. barfoob_foo
D. foobarb_fpp
- 以下程序输出结果是( )
cpp
class A
{
public:
virtual void func(int val = 1)
{ std::cout<<"A->"<<val <<std::endl;}
virtual void test()
{ func();}
};
class B : public A
{
public:
void func(int val=0) {std::cout<<"B->"<<val <<std::endl;}
};
int main(int argc ,char* argv[])
{
B*p = new B;
p->test();
return 0;
}
A. A->0
B. B->1
C. A->1
D. B->0
- 下面这段代码运行时会出现什么问题?
cpp
class A
{
public:
void f()
{
printf("A\n");
}
};
class B: public A
{
public:
virtual void f()
{
printf("B\n");
}
};
int main()
{
A *a = new B;
a->f();
delete a;
return 0;
}
- 代码执行后,a和b的值分别为( )
cpp
class Test {
public:
int a;
int b;
virtual void fun() {}
Test(int temp1 = 0, int temp2 = 0)
{
a = temp1;
b = temp2;
}
int getA()
{
return a;
}
int getB()
{
return b;
}
};
int main()
{
Test obj(5, 10);
// Changing a and b
int* pInt = (int*)&obj;
*(pInt + 0) = 100;
*(pInt + 1) = 200;
cout << "a = " << obj.getA() << endl;
cout << "b = " << obj.getB() << endl;
return 0;
}
A. 200 10
B. 5 10
C. 100 200
D. 100 10
参考答案
- B
%m:ns
:其中m
表示输出字符串的宽度;n
表示左起截取目标字符串 n 个字符进行输出,并且是右对齐,左边补空格。 - C
参考学习C语言结构体【内存对齐】与【实现位段】 - B
a
先和方括号结合,a
是一个三行四列的二维数组;**
是指针类型,32位系统下是4个字节,所以有4 * 12 = 48
。 - B
小端存储:低位数据存放到低地址处。
内存中,
a
的存储是:01 00 00 00 00 00 00 00
b
的存储是:02 00 00 00 00 00 00 00
c
的存储是:03 00 00 00 00 00 00 00
之后调用printf
函数,要创建函数栈帧。栈帧的创建是从高地址往低地址创建。
函数传参压栈是从右向左进行的。
所以有如下的栈帧情况:
按%d
打印,是打印4个字节,
所以第一次打印01 00 00 00
,所以第一次打印00 00 00 00
,所以第一次打印02 00 00 00
,
即1,0,2。 - C
m
是八进制数,n
是十进制数,%o
是按照八进制进行打印。 - A
sizeof
计算变量所对应类型占的字节数。 - C
参考C语言结构体【内存对齐】与【实现位段】。 - B
初始化列表只能对类中非静态成员变量进行初始化。
const修饰的成员变量,引用类型的成员变量,类类型对象且该类没有默认的构造函数,这三种成员必须在初始化列表位置进行初始化。 - D
如果类中具有单个参数的构造函数,该构造函数具有类型转换的作用。编译器在编译代码阶段,会调用单参构造函数进行类型转换。 - E
引用底层是使用指针实现的,引用本质还是指针。 - D
- C
- B
new的原理是:a.申请空间,b.调用构造函数对申请的空间进行初始化。如果构造函数私有了,就无法new创建对象了。delete的原理:a.调用类的析构函数,b.释放空间。析构函数私有了,会影响对象空间的delete释放。 - C
常成员函数是指const成员函数,此时的const修饰this指针,表示在该成员函数中,不能修改类的非静态成员变量。 - B
MyClass a[5]有是5个MyCLass类型对象的一个数组,需要调用5次MyClass类的构造函数;MyClass* b[6]是一个指针数组,该数组中的每个元素存放的都是MyClass*类型的指针。 - D
C++中cosnt修饰的变量,就相当于一个常量,是具有替换作用的。在编译阶段,会将const修饰的变量替换成常量。 - C
首先,不能在析构函数中delete this
cpp
~myClass(){
delete this;
}
上面代码可以通过编译,但运行会奔溃。
delete this
有两个作用,一是调用析构函数释放对象中的资源,二是调用operator delete
释放对象的空间。
所以,析构函数中delete this
会形成无限递归,导致程序运行栈溢出崩溃。
并不是所有的对象都是从对象new
出来的,所以不能一味地delete this
。
this=NULL
编译会失败,要知道this
类型是myClass* const
的,this
指针的指向不能被修改。
- C
类里面也可以没有拷贝构造函数。 - C
堆只能动态分配(运行时决定分配空间的大小),栈静态和动态分配都可以。 - A
- A
- F
d在类外初始化。 - C
- A
- B
虚函数接口继承。 - 运行时崩溃。子类的虚表指针安放有问题。
- A
头部存放的有虚表指针。