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;

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）

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;
}