c、c++ 基础试题（1）

1、以下程序的输出结果是什么？

main()
{
    char *p1 = "name";
    char *p2;
    p2 = (char*)malloc(20);
    memset(p2, 0, 20);
    while(*p2++ = *p1++);
    printf("%s",p2);
}

 

2、以下程序的输出结果是什么？

main()
{
    int x = 20, y = 35; 
    x = y++ + x++; 
    y = ++y + ++x; 
    printf("%d,%d",x,y);
}

main()
{
    int arr[] = {6, 7, 8, 9, 10};
    int *ptr = arr;
    *(ptr++) += 123;
    printf("%d, %d", *ptr, *(++ptr));
}

 

3、以下程序的输出结果是什么？

main() 
{ 
    int x = 5; 
    printf("%d,%d,%d",x,x<<2,x>>2); 
}

 

4、以下程序的输出结果是什么？

main()
{ 
    char *ptr = " Cisco Systems";
    *ptr++; printf("%s", ptr);
    ptr++;
    printf("%s",ptr);
}

 

5、以下程序的输出结果是什么？

main()
{ 
    char s1[] = "Cisco"; 
    char s2[] = "systems"; 
    printf("%s", s1); 
}

 

6、以下程序的输出结果是什么？

main()
{ 
    char *p1; 
    char *p2; 
    p1 = (char *)malloc(25); 
    p2 = (char *)malloc(25); 

    strcpy(p1, "Cisco"); 
    strcpy(p2, "systems"); 
    strcat(p1, p2); 

    printf("%s", p1); 
} 

 

7、以下程序的输出结果是什么？

main()
{ 
    int x = 10, y = 15; 
    x = x++; 
    y = ++y; 
    printf("%d %d",x,y); 
}

main()
{
    int a,b,c,d;
    a=10;
    b=a++;
    c=++a;
    d=10*a++;
    printf("b，c，d：%d，%d，%d"，b，c，d);
    return 0;
}

 

8、以下程序的输出结果是什么？

#include <stdio.h>
#include <iostream.h>

struct bit 
{
   int a:3; 
   int b:2; 
   int c:3; 
};
 
int main(int argc, char* argv[]) 
{ 
   bit s; 
   char *c = (char*)&s; 
   *c = 0x99; 
   cout << s.a << s.b << s.c;
   return 0; 
} 

 

9、以下程序的输出结果是什么？

#include <iostream>
using namespace std;

int main()
{
    int num[5] = {1,2,3,4,5};
    cout<<*((int *)(&num+1)-2)<<endl;

    return 0;
}

 

10、以下程序的输出结果是什么？

main()
{
   struct node 
   {
       int a;
       int b;
       int c;     
   };
   struct node s= {3, 5, 6};
   struct node *pt = &s;
   printf("%d", *(int*)pt);
}

 

11、以下程序的输出结果是什么？

main() 
{
    int a[5] = {1, 2, 3, 4, 5};
    int *ptr = (int*)(&a+1);
    
    printf("%d %d" , *(a+1), *(ptr-1));
}

 

12、以下程序的输出结果是什么？

void foo(int [][3]);     

main()
{
    int a[3][3]= {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    foo(a);
    printf("%d", a[2][1]);
}

void foo(int b[][3])   
{
    ++ b;
    b[1][1] =9;
}

 

13、以下程序的输出结果是什么？

main()
{
    int a, b,c, d;
    
    a=3;
    b=5;
    c=a,b;
    d=(a,b);

    printf("c=%d", c);
    printf("d=%d", d);
}

 

14、以下程序的输出结果是什么？

main()
{
    int a[][3] = {1, 2, 3, 4, 5, 6};
    int (*ptr)[3] = a;

    printf("%d %d", (*ptr)[1], (*ptr)[2]);

    ++ptr;
    printf("%d %d", (*ptr)[1], (*ptr)[2]);
}

 

15、以下程序的输出结果是什么？

main()
{
    int i=3;
    int j;  

    j = sizeof(++i+++i);
    
    printf("i=%d j=%d", i, j);
}

main()
{
    int **a[3][4];

    printf("%d", sizeof(a));
}

 

16、以下程序的输出结果是什么？

void e(int);   

main()
{
    int a;
    a = 3;
    e(a);
}

void e(int n)
{
    if(n > 0)
    {
        e(--n);
        printf("%d", n);
        e(--n);
    }
}

 

17、以下程序的输出结果是什么？

void f(char**);

main()
{
    char * argv[] = {"ab", "cd", "ef", "gh", "ij", "kl"};
    f(argv);
}

void f(char **p)
{
    char *t;

    t = (p += sizeof(int))[-1];
   
    printf("%s", t);
}

 

18、以下程序的输出结果是什么？

#include <iostream>
using namespace std;

struct s1
{
    char a;
    double b;
    int c;
    char d; 
};

struct s2
{
    char a;
    char b;
    int c;
    double d;
};

int main()
{
    cout<<sizeof(double)<<endl; // 8
    cout<<sizeof(s1)<<endl;
    cout<<sizeof(s2)<<endl;
}

 

19、以下程序的输出结果是什么？

#include <stdio.h>

int main()
{
    unsigned int a = 6;
    int b = -20;
    (a+b > 6) ? puts("> 6") : puts("<= 6");
}

 

20、以下程序的输出结果是什么？

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char *ptr;

    if ((ptr = (char *)malloc(0)) == NULL) 
        puts("Got a null pointer");
    else
        puts("Got a valid pointer");
}

 

21、32位系统下，以下程序的输出结果是什么？

#include <stdio.h>
#include <stdlib.h>

void func(char str[100])
{
    printf("%d", sizeof(str));
}

int main()
{
    char str[] = "Hello" ;
    char *p = str ;
    int n = 10;
    void *q = malloc(100);
    
    printf("%d %d %d %d\n", sizeof(str), sizeof(p), sizeof(n), sizeof(q));
    func(str);
}

 

22、以下程序的输出结果是什么？

#include <stdio.h> 

int inc(int a)
{
    return (++a);
}

int multi(int *a, int *b, int *c)
{
    return(*c = *a * *b);
} 

typedef int(FUNC1)(int);
typedef int(FUNC2)(int*, int*, int*);

void show(FUNC2 fun, int arg1, int *arg2)
{
    FUNC1 p = &inc;
    int temp = p(arg1);
    fun(&temp, &arg1, arg2);

    printf("%d\n", *arg2);
}

main()
{
    int a;
    show(multi, 10, &a); 
    return 0; 
}

 

23、变量的声明和定义有什么区别？

声明一个变量、函数甚至是类时，是在告诉编译器存在一个这种名字的东西，并且拥有类型。然后编译器就可以做很多事情，而不需要把这个名字的详细定义。当工作于一个多源文件系统，在多个文件中使用函数时，这个特别有用。你不需要在多个文件中都放入函数体，只需要提供对它的声明。

声明的例子：

extern int x;
extern short *count;
extern char *live[MAX_COUNT];
extern enum emreg rclass[REGS];
extern struct gfile *gfiles;
extern opta add_opta;
extern tree build(), retrieve(), destroy();
int push_operand ();
int gene_operand ();
class CDoneCap;

  

具体参考：http://www.cprogramming.com/declare_vs_define.html

 

24、sizeof和strlen的区别？

(1) sizeof是一个操作符，strlen是库函数；
(2) sizeof的参数可以是数据的类型，也可以是变量，而strlen只能以结尾为‘\0‘的字符串作参数；
(3) 编译器在编译时就计算出了sizeof的结果。而strlen 函数必须在运行时才能计算出来。并且sizeof计算的是数据类型占内存的大小，而strlen计算的是字符串实际的长度；
(4) 数组做sizeof的参数不退化，传递给strlen就退化为指针了。

 

25、简述C、C++程序编译的内存分配情况

C、C++中内存分配方式可以分为三种：
(1) 从静态存储区域分配：
内存在程序编译时就已经分配好，这块内存在程序的整个运行期间都存在。速度快、不容易出错，因为有系统会善后。例如全局变量，static变量等。
(2) 在栈上分配：
在执行函数时，函数内局部变量的存储单元都在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
(3) 从堆上分配：
即动态内存分配。程序在运行的时候用malloc或new申请任意大小的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由程序员决定，使用非常灵活。如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，另外频繁地分配和释放不同大小的堆空间将会产生
堆内碎块。
一个C、C++程序编译时内存分为5大存储区：堆区、栈区、全局区、文字常量区、程序代码区。

 

26、设置地址为0x12ff7c的整型变量的值为0xaa66

int main()
{
    int *ptr;  
    ptr = (int *)0x12ff7c;
    *ptr = 0xaa66;
}

 

27、用变量a给出下面的定义

a) 一个整型数（An integer）
b) 一个指向整型数的指针（A pointer to an integer）
c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）
d) 一个有10个整型数的数组（An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（An array of ten pointers to functions that take an integer argument and return an integer）

参考资料：http://unixwiz.net/techtips/reading-cdecl.html

 

28、评价下面的代码片段

#include <stdio.h>

int main()
{
    unsigned int zero = 0;
    unsigned int compzero = 0xFFFF;
}

 

29、以下是定义dPS 和 tPS 作为一个指向结构s的指针，哪种方法更好？（如果有的话）为什么？

#define dPS struct s *
typedef struct s * tPS;

 

30、置位和清位

#include <stdio.h>

#define BIT5 (0x1 << 5)

int main()
{
    int a;

    a |= BIT5;
    a &= ~BIT5;
}

 

31、写一个C函数，若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1

#include <stdio.h>

int checkCPU()
{
    {
        union w
        {
            int  a;
            char b;
        } c;
        c.a = 1;
        return(c.b == 1);
    }
}

int main()
{
    printf("%s\n", checkCPU() ? "Little_endian" : "Big_endian");
}

 

32、在C++程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？

答：C++语言支持函数重载，C语言不支持函数重载。函数和变量被C++编译后在符号库中的名字与C语言的不同，被extern "C"修饰的变量和函数是按照C语言方式编译和连接的。由于编译后的名字不同，C++程序不能直接调用C 函数。C++提供了一个C 连接交换指定符号extern“C”来解决这个问题。假设某个函数的原型为： void foo(int x, int y); 该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。

 

33、以下各程序是否存在问题，如果有，是哪些？

void GetMemory(char *p)
{
    p = (char *)malloc(100);
}

void Test(void) 
{
    char *str = NULL;
    GetMemory(str);
    strcpy(str, "hello world");
    printf(str);
}

char *GetMemory(void)
{ 
    char p[] = "hello world";
    return p;
}

void Test(void)
{
    char *str = NULL;
    str = GetMemory(); 
    printf(str);
}

void GetMemory2(char **p, int num)
{
    *p = (char *)malloc(num);
}

void Test(void)
{
    char *str = NULL;
    GetMemory(&str, 100);
    strcpy(str, "hello"); 
    printf(str); 
}

void Test(void)
{
    char *str = (char *) malloc(100);
    strcpy(str, "hello");
    free(str); 
    if(str != NULL)
    {
        strcpy(str, "world"); 
        printf(str);
    }
}

 

34、请找出下面代码中的所有错误

说明：以下代码是把一个字符串倒序，如“abcd”倒序后变为“dcba”

#include "string.h" 

void main() 
{  
    char *src = "hello,world"; 
    char *dest = NULL; 

    int len = strlen(src);  
    dest = (char*)malloc(len);

    char *d = dest; 
    char *s = src[len]; 
    while(len-- != 0) 
        d++ = s--;  

    printf("%s",dest); 
} 

 

35、下述三个有什么区别？ 

char * const p;
char const * p;
const char *p;

 

36、以下代码的输出结果是什么？

#include <iostream.h>

void main() 
{  
    char str1[] = "abc"; 
    char str2[] = "abc";  
    const char str3[] = "abc"; 
    const char str4[] = "abc"; 
    const char *str5 = "abc"; 
    const char *str6 = "abc"; 
    char *str7 = "abc"; 
    char *str8 = "abc";  
    
    cout << (str1 == str2) << endl; 
    cout << (str3 == str4) << endl; 
    cout << (str5 == str6) << endl; 
    cout << (str7 == str8) << endl; 
} 

 

37、以下代码有什么错？

#include <stdio.h>

void main() 
{  
    char* s = "AAA";
    printf("%s", s);

    s[0] = 'B';
    printf("%s", s);
} 

以下两题谁对谁错？

main()
{
    char s[] = "abc";
    Reverse(s);
    printf("%s", s);
}

main()
{
    char *s = "abc";
    Reverse(s);
    printf("%s", s);
}

 

38、实现字符串拷贝函数char *strcpy(char *dest,char *src)

extern char *strcpy(char *dest, char *src); 
{  
    ASSERT((dest!=NULL)&&(src!=NULL)); 
    char *address = dest;  
    While((*dest++ = *src++) != '\0') 
        continue;
    return dest; 
}

 

39、实现字符串比较函数int strcmp(char *source, char *dest)，相等返回0，不等返回-1；

int strcmp(char *source, char *dest)
{
    assert((source!=NULL)&&(dest!=NULL));
    int i,j;
    for(i=0; source[i]==dest[i]; i++)
    {
        if(source[i]=='\0' && dest[i]=='\0')
            return 0;
        else
            return -1;
    }
}

int strcmp(char *source, char *dest)
{
    while ( (*source != '\0') && (*source == *dest))
    {
        source++;
        dest++;
    }
    return ( (*source) - (*dest) ) ? -1 : 0;
}

 

40、实现内存拷贝函数void *memcpy(void *dest, void *src, unsigned int count)

extern void *memcpy(void *dest, void *src, unsigned int count)
{  
    ASSERT((dest != NULL) && (src != NULL));  
    ASSERT((dest > src + count) || (src > dest + count));//防止内存重叠 
    
    byte *bdest = (byte*)dest; 
    byte *bsrc = (byte*)src; 
    While(count-- > 0) 
        *bdest++ = *bsrc++; 
    return dest;
}

 

41、实现字符串连接函数char *strcat (char *strDest, const char *strSrc)

char * __cdecl strcat (char * dst, const char * src)
{
    char * cp = dst;
    while( *cp )
        cp++; /* find end of dst */
    while( *cp++ = *src++ ) ; /* Copy src to end of dst */
    return( dst ); /* return dst */
}

 

42、以下程序的运行结果是什么？

int sum(int a)
{
    auto int c=0;
    static int b=3;
    c+=1;
    b+=2;
    return(a+b+C);
}
　　
void main()
{
    int I;
    int a=2;
    for(I=0;I<5;I++)
    {
        printf("%d,", sum(a));
    }
}

 

43、以下程序的运行结果是什么？

int func(int a)
{
    int b;
    switch(a)
    {
        case 1: b=30;
        case 2: b=20;
        case 3: b=16;
        default: b=0;
    }
    return b;
}

 

44、以下程序的输出结果是什么？

main()
{
    int a[3] = {0, 1, 2};
    int *p, *q;
    p = a;
    q = &a[2];

    printf("%d", a[q-p]);
}

 

45、以下代码的输出结果是什么？

main()
{
    unsigned short A = 10;
    printf("~A = %u\n", ~A);

    char c=128;
    printf("c = %d\n",c);
}

 

46、已知

unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;

请问
p1 + 5 = ______;
p2 + 5 = ______;

 

47、以下3个函数中最可能引起指针方面的问题是哪几个？

int *f1(void)
{
    int x =10;
    return(&x);
}

int *f2(void)
{
    int*ptr;
    *ptr =10;
    return ptr;
}

int *f3(void)
{
    int *ptr;
    ptr=(int*) malloc(sizeof(int));
    return ptr;
}