C++小题（八）

/////////////////////////////////////////////////////////////
/*
字符串"Hello"会被输出几次?
int main() {
 printf("Hello");
 fork();
 printf("Hello");
}
正确答案: C   你的答案: C (正确)
A2
B3
C4
D6
print输出字符串如果不是一"\n"为结尾的话，就不会马上输出，而是保存在缓存区中。fork函数在创建子进程的时候会复制缓存区的数据。
*/
/////////////////////////////////////////////////////////////
/*
下面两段代码中for循环分别执行了多少次？
unsigned short i,j;
for(i=0, j=2; i!=j; i+=5, j+=7)
{}
 
unsigned short i,j;
for(i=3,j=7;i!=j;i+=3,j+=7)
{}

正确答案: A   你的答案: A (正确)

32767 16383
32767 16363
33787 16363
33787 16383
答案分析：unsigned short能表示2^16个数，其范围为0~2^16-1，j在i前2个位置，i以5的速度增长，j以7的速度增长，
当增长到unsigned short表示的最大值又会返回0（以一个圈的形式循环）开始重新走直到i、j相遇，
所以就是7t - 5t + 2 = 216，所以为32767次
第二个类似 (7t + 7)-(5t - 3) = 216,所以为16383次
*/
/////////////////////////////////////////////////////////////
/*
下面有关java和c++的描述，错误的是？
正确答案: B   

A java是一次编写多处运行，c++是一次编写多处编译
B c++和java支持多重承
C Java不支持操作符重载，操作符重载被认为是c++的突出特征
D java没有函数指针机制，c++支持函数指针

JAVA没有指针的概念，被封装起来了，而C++有;
JAVA不支持类的多继承，但支持接口多继承，C++支持类的多继承;C++支持操作符重载，JAVA不支持;
JAVA的内存管理比C++方便，而且错误处理也比较好;C++的速度比JAVA快。
C++更适用于有运行效率要求的情况，JAVA适用于效率要求不高，但维护性要好的情况。
*/
/////////////////////////////////////////////////////////////
/*
下面关于迭代器失效的描述哪个是错误的（）
正确答案: A   

A vector的插入操作不会导致迭代器失效
B map的插入操作不会导致迭代器失效
C vector的删除操作只会导致指向被删除元素及后面的迭代器失效
D map的删除操作只会导致指向被删除元素的迭代器失效

vector是顺序存储的，只有在尾部插入才不会导致迭代器失效，在头部插入或者中间插入都会导致插入的部位以及其后的所有迭代器都失效；
map是映射，key和value是一一对应的，在内存中是零散存在的，迭代器通过key找到value，无论怎么插入都不会让迭代器失效，
当然删除只会使得被删除元素的迭代器失效
*/
/////////////////////////////////////////////////////////////
/*
下面重载乘法运算符的函数原型声明中正确的是:
正确答案: A B D   你的答案: B D (错误)

A MyClass operator *(double ,MyClass);
B MyClass operator *(MyClass ,MyClass);
C MyClass operator *(double ,double);
D MyClass operator *(MyClass ,double);
c++中规定，重载运算符必须和用户定义的自定义类型的对象一起使用。
*/
/////////////////////////////////////////////////////////////
/*
以下叙述中错误的是？
正确答案: C   你的答案: C (正确)

A数值型常量有正值和负值的区分
B常量可以用一个符号名来代表
C定义符号常量必须用类型名来设定常量的类型
D常量是在程序运行过程中值不能被改变的量
# define N 10.反例
*/
/////////////////////////////////////////////////////////////
/*
下面程序执行结果:
using namespace std;
class A{
    public:
        virtual void f() { cout << "A::f() "; }
        void f() const { cout << "A::f() const "; }
};
class B : public A {
    public:
        void f() { cout << "B::f() "; }
        void f() const { cout << "B::f() const "; }
};
void g(const A* a) {
    a->f();
}
int main(int argc, char *argv[]) {
    A* p = new B();
    p->f();
    g(p);
    delete(p);
    return 0;
}
正确答案: B   你的答案: B (正确)

A B::f() B::f() const
B B::f() A::f() const
C A::f() B::f() const
D A::f() A::f() const
常量指针指向常对象, 常对象只能调用其常成员函数,因此通过g(const A* a)调用的是void f() const;
*/
/////////////////////////////////////////////////////////////
/*
派生类的对象对它的基类成员中，（）是可以访问的。
正确答案: A   你的答案: A (正确)

A公有继承的公有成员
B公有继承的私有成员
C公有继承的保护成员
D私有继承的公有成员

B，公有继承的私有成员不能被继承，无法访问
C，公有继承的保护成员，只能在派生类中访问，不能用派生类对象访问
D，私有继承的公有成员，成员被私有化，无法访问
*/
/////////////////////////////////////////////////////////////
/*
下面有关final, finally, finalize的区别描述错误的是？
正确答案: B   你的答案: B (正确)

A 如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承
B 如果一个方法被声明为final，可以被覆盖
C finally在异常处理时提供 finally 块来执行任何清除操作。
D Java使用 finalize() 方法在垃圾收集器象从内存中清除出去之前做必要的清理工作

final关键字可用于修饰类、变量和方法。
final修饰的类不能被继承，
final修饰的方法不能被重写，
final修饰的变量不可被修改，一旦获得初始值，该变量就不能被重新赋值。
*/
/////////////////////////////////////////////////////////////
/*
下列给定程序的功能是：调用函数fun将指定源文件中的内容复制到指定的目标文件中，复制成功时函数返回1，失败时返回0。在复制的过程中，把复制的内容输出到屏幕。主函数中源文件名放在变量afname中，目标文件名放在变量tfname中。
请在程序的下画线处填入正确的内容并将下画线删除，使程序得出正确的结果。 
试题程序。
#include <stdlib.h>
#include <stdlib.h>
int fun(char *source, char *target)
{
        FILE *fs, *ft; char ch;

        if ((fs = fopen(source,   1 ) == NULL)
            return 0;
        if ((ft = fopen(target, "w")) == NULL)
            return 0;
        printf("\nThe data in file :\n");
        ch = fgetc(fs);

        while (!feof（ 2 ）)                 
        {
            putchar(ch);

            fputc(ch, 3 );
            ch = fgetc(fs);
                   
        }
        fclose(fs);
        fclose(ft);
        printf("\n\n");
        return 1;
}
"r",fs,ft
*/
/////////////////////////////////////////////////////////////
/*
In C++, which of the following keyword(s) can be used on both a variable and a function?
正确答案: A C E   你的答案: A C E (正确)

A static
B virtual
C extern
D inline
E const

static 静态变量和静态函数都可以在类外直接访问，
extern 可以用于声明变量，但是函数声明也可以用，只不过默认就是extern而已。
const也可以修饰函数或者变量
*/
/////////////////////////////////////////////////////////////
/*
下述程序有什么问题？
#include   <string.h>
#include   <stdio.h> 
#include   <stdlib.h> 
void getmemory(char*p)  {    
    p=(char *) malloc(100);    
    strcpy(p,"hello world");  
}  
int main( ) 
{    
    char *str=NULL;    
    getmemory(str);    
    printf("%s\n",str);   
    free(str);    
    return 0;    
}

正确答案: B   你的答案: B (正确)

A正常输出'hello world"
B输出为空
C输出"烫烫烫"
D程序崩溃

free(ptr)
如果ptr为NULL，则不会做任何操作
如果ptr未定义，则会崩溃。

指针指向常量（如char*str=“aaaaa”）和NULL时，不能通过指针修改常量，因为常量本身就是只读的。
退一步来讲，getmemory函数中，p一开始跟str指向同一个位置，经过“ p=(char*) malloc(100);”
这句话之后p已经指向了动态开辟的空间的首地址，“strcpy(p,"hello world");”
操作针对的是动态开辟的空间，而不是str指向的地址空间了，getmemory函数执行完成后p又自动释放了，
所以getmemory函数对str指向的地址空间没有实际的操作。
综上可知，str指向的内容未发生变化，故输出NULL。
*/
/////////////////////////////////////////////////////////////
/*
C++中关于堆和栈的说法，哪个是错误的:
正确答案: C   你的答案: C (正确)

A堆的大小仅受操作系统的限制，栈的大小一般一般较小
B在堆上频繁的调用new/delete容易产生内存碎片，栈没有这个问题
C堆和栈都可以静态分配
D堆和栈都可以动态分配

静态分配是指在编译阶段就能确定大小，由编译器进行分配，堆不可以进行静态分配，堆的申请都是在执行过程中进行的。
A，堆和栈的大小都可以设置，栈一般只有几KB。
B，堆在动态分配时，要申请连续的内存空间，释放后会产生碎片。
D，堆是使用malloc()、calloc()、realloc()等函数动态分配的，
而使用alloca()函数可以动态分配栈的内存空间，释放的时候由编译器自己释放。不能用free()去释放，会导致错误
*/
/////////////////////////////////////////////////////////////
/*
若有一下程序
#include<stdio.h>
main(){
    int b=10,a=－11;
    a%=b%=4;
    printf("%d %d\n",a,B);
｝
  则程序的输出结果是？
正确答案: B   你的答案: B (正确)

A1 2
B－1 2
C－1 －2
D1 －2
如果只看c++和java里的话，就是余数随被除数符号（重要的事情说3遍）
根据取余的定义来考虑。a%b=a-a/b*b；这样结果就不会出错了。
*/
/////////////////////////////////////////////////////////////
/*
void func()
{
   char b[2]={0};
   strcpy(b,"aaaa");
}
以下说法那个正确()
正确答案: A   

A Debug版崩溃，Release版正常
B Debug版正常，Release版崩溃
C Debug版崩溃，Release版崩溃
D Debug版正常，Release版正常
因为在Debug中有ASSERT断言保护，所以要崩溃，
而在Release优化中就会删掉ASSERT,所以会出现正常运行。
但是不推荐如此做，因为这样会覆盖不属于自己的内存，即未定义行为，出现什么后果都有可能的，
程序员的职责是保证不越界，而不是追问越界之后会发生什么。
*/
/////////////////////////////////////////////////////////////
/*
开发C代码时,经常见到如下类型的结构体定义:
typedef struct list_t{
	struct list_t *next;
	struct list_t *prev;
	char data[0];
}list_t;
请问在32位系统中,sizeof(list_t)的值为?
正确答案: B   

A 4byte
B 8byte
C 5byte
D 9byte

柔性数组不占内存,和内存对齐
*/
/////////////////////////////////////////////////////////////
/*
下面有关volatile说法正确的有？
正确答案: A B C   你的答案: A B C (正确)

A当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后再取变量值时，就直接从寄存器中取值
B优化器在用到volatile变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份
Cvolatile适用于多线程应用中被几个任务共享的变量
D一个参数不可以既是const又是volatile

一个参数既可以是const还可以是volatile. 一个例子是只读的状态寄存器。
它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

Java 语言提供了一种稍弱的同步机制,即 volatile 变量.用来确保将变量的更新操作通知到其他线程,
保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新. 
当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的.
*/
/////////////////////////////////////////////////////////////
/*
数字字符0的ASCII值为48,若有以下程序:
main()
{
    char a=’1’,b=’2’;
    printf(“%c,”,b++);
    printf(“%d\n”,b-a);
}
程序运行之后的输出结果是:
正确答案: C   

A3,2
B50,2
C2,2
D2,50
*/
/////////////////////////////////////////////////////////////
/*
c++中，声明const int i,是在哪个阶段做到 i只可读的？
正确答案: A   你的答案: A (正确)

A编译
B链接
C运行
D以上都不对

const用来说明所定义的变量是只读的。 这些在编译期间完成，编译器可能使用常数直接替换掉对此变量的引用
*/
/////////////////////////////////////////////////////////////
/*
#include <stdio.h>
void fun ( char *p,int n )  
{
    char b [6] ＝ "abcde"; int i;
    for ( i ＝ 0,p ＝ b;i < n;i + + ) 
        p [i] ＝ b [i];
}
main( )
{
    char a [6] ＝ "ABCDE";
    fun (a,5); 
    printf ("%s\n",a ) ;
｝
程序运行后的输出结果是？
正确答案: B   你的答案: B (正确)

A abcde
B ABCDE
C edcba
D EDCBA
本题考查数组名作为函数参数,执行f函数时,传进去的a指针被重新指向了b,
所以原本a数组的地址内容不变,所以输出结果为ABCDE,答案为B选项。
若改为： 
void fun (char *p,int n ) 
{
    char b [6] = "abcde"; int i;
    for (i = 0;i < n;i++){
    	p [i] = b [i];
	}
        
}则输出abcde 
*/
/////////////////////////////////////////////////////////////
/*
enum string{    
    x1,    
    x2,    
    x3=10,    
    x4,    
    x5,    
} x;
函数外部问x等于什么？
正确答案: C   

A 5
B 12
C 0
D 随机值

在全局域定义enum，输出x是0，但是在局部域定义enum,输出x是随机数。
*/
/////////////////////////////////////////////////////////////
/*
关于函数模板,描述错误的是？ 
正确答案: A   你的答案: A (正确)

A函数模板必须由程序员实例化为可执行的函数模板
B函数模板的实例化由编译器实现
C一个类定义中，只要有一个函数模板，则这个类是类模板
D类模板的成员函数都是函数模板，类模板实例化后，成员函数也随之实例化

正确的说法是函数模板必须由编译器根据程序员的调用类型实例化为可执行的函数。
*/
/////////////////////////////////////////////////////////////
/*
下面描述中,表达正确的有()
正确答案: A C D   

A公有继承是基类中的public成员在派生类中仍是public的
B公有继承是基类中的private成员在派生类中仍是private的
C公有继承是基类中的protected成员在派生类中仍是protected的
D私有继承是基类中的public成员在派生类中是private的

公用（public）：访问权限最高；除派生类外，外部函数也可以直接访问（无论是成员变量还是成员函数）。 
私有（private）：访问权限最低；只能是该类内部函数互相调用，派生类、外部函数都不能访问。 
保护（protect）：访问权限中间；该类内部函数、派生类都能访问，外部类、外部函数不能访问  
*/
/////////////////////////////////////////////////////////////
/*
如何捕获异常可以使得代码通过编译？
class A {
  public:
        A(){}
};
void foo(){
    throw new A;
}
正确答案: B   

A catch (A && x)
B catch (A * x)
C catch (A & x)
D 以上都是
题目中问的是能否通过编译，只有B会捕获到异常，进行异常处理，
而A和C由于和throw抛出的异常类型不匹配，导致这个异常不被捕获，从而成为未捕获的异常，调用terminate函数结束程序。
*/
/////////////////////////////////////////////////////////////
/*
有一个如下的结构体：
struct A{
 long a1;
 short a2;
 int a3;
 int *a4;
};
请问在64位编译器下用sizeof(struct A)计算出的大小是多少？
正确答案: A   

A 24
B 28
C 16
D 18
Win64下：long 8字节、short 2字节、int 4字节、int* 8字节，C++中内存对齐，按最大长度对齐：8+（2+4+2（补齐2字节））+8 = 24字节
*/
/////////////////////////////////////////////////////////////
/*
代码生成阶段的主要任务是：
正确答案: C   你的答案: C (正确)

A把高级语言翻译成机器语言
B把高级语言翻译成汇编语言
C把中间代码变换成依赖具体机器的目标代码
D把汇编语言翻译成机器语言

源码 ->（扫描）-> 标记 ->（语法分析）-> 语法树 ->（语义分析）-> 标识语义后的语法树 ->（源码优化）-> 中间代码 ->（代码生成）-> 目标机器代码 ->（目标代码优化）-> 最终目标代码
*/
//////////////////////////////////////////////////////////////
/*
在 C 语言中下面那个语句的结果是 1 ？
正确答案: B C   

A main 函数正常结束的返回值
B return 7&1;
C char *p="hello"; return p == "hello";
D 上面都不对
*/
//////////////////////////////////////////////////////
/*
extern "C"{}的作用以及能解决什么问题？
正确答案: A B   

A在C++源文件中的语句前面加上extern "C"，表明它按照类C的编译和连接规约来编译和连接，而不是C++的编译的连接规约
B主要是解决在C++代码中调用C代码
C主要是解决在C代码中调用C++代码
D上述描述都不正确

*/