中文字幕理论片,69视频免费在线观看,亚洲成人app,国产1级毛片,刘涛最大尺度戏视频,欧美亚洲美女视频,2021韩国美女仙女屋vip视频

1.編寫my_strcpy函數(shù)，實現(xiàn)與庫函數(shù)strcpy類似的功能，不能使用任何庫函數(shù)；
答：char *strcpy(char *strDest, const char *strSrc)
{
if ( strDest == NULL || strSrc == NULL)
return NULL ;
if ( strDest == strSrc)
returnstrDest ;
char *tempptr = strDest ;
while( (*strDest++ = *strSrc++) != ‘’);
returntempptr ;
}

2. 頭文件中的ifndef/define/endif的作用？
答：防止該頭文件被重復引用。

3. ＃i nclude與＃i nclude “file.h”的區(qū)別？
答：前者編譯器從標準庫路徑開始搜索file.h，而后者編譯器從用戶的工作路徑開始搜索file.h。

4. 在C++ 程序中調(diào)用被C 編譯器編譯后的函數(shù)，為什么要加extern“C”？
答：extern是C/C++語言中表明函數(shù)和全局變量作用范圍（可見性）的關鍵字，其聲明的函數(shù)和變量可以在本模塊或其它模塊中使用。
通常，在模塊的頭文件中對本模塊提供給其它模塊引用的函數(shù)和全局變量以關鍵字extern聲明。

5. 面向?qū)ο蟮娜齻€基本特征，并簡單敘述之？
答：1）封裝：將客觀事物抽象成類，每個類對自身的數(shù)據(jù)和方法實行protection(private, protected,public)
2）繼承：實現(xiàn)繼承（指使用基類的屬性和方法而無需額外編碼的能力）、可視繼承（子窗體使用父窗體的外觀和實現(xiàn)代碼）、接口繼承（僅使用屬性和方法，實現(xiàn)滯后到子類實現(xiàn)）。
3）多態(tài)：允許將子類類型的指針賦值給父類類型的指針。

6. 重載（overload)和重寫(overried，有的書也叫做“覆蓋”）的區(qū)別？
答：從定義上來說：
重載：是指允許存在多個同名函數(shù)，而這些函數(shù)的參數(shù)表不同（或許參數(shù)個數(shù)不同，或許參數(shù)類型不同，或許兩者都不同）。
重寫：是指子類重新定義復類虛函數(shù)的方法。
從實現(xiàn)原理上來說：
重載：編譯器根據(jù)函數(shù)不同的參數(shù)表，對同名函數(shù)的名稱做修飾，然后這些同名函數(shù)就成了不同的函數(shù)。
重寫：當子類重新定義了父類的虛函數(shù)后，父類指針根據(jù)賦給它的不同的子類指針，動態(tài)的調(diào)用屬于子類的該函數(shù)，這樣的函數(shù)調(diào)用在編譯期間是無法確定的（調(diào)用的子類的虛函數(shù)的地址無法給出）。

7. 多態(tài)的作用？
答：主要是兩個：1）隱藏實現(xiàn)細節(jié)，使得代碼能夠模塊化；擴展代碼模塊，實現(xiàn)代碼重用；2）接口重用，為了類在繼承和派生的時候，保證使用家族中任一類的實例的某一屬性時的正確調(diào)用。

8. 分別寫出BOOL,int,float,指針類型的變量a 與“零”的比較語句。
答：BOOL :if ( !a ) or if(a)
int :if ( a ==0)
float :const EXPRESSION EXP = 0.000001
if ( a < EXP && a >-EXP)
pointer : if ( a != NULL) or if(a == NULL)

9. 請說出const與#define 相比，有何優(yōu)點？
答案：1） const 常量有數(shù)據(jù)類型，而宏常量沒有數(shù)據(jù)類型。編譯器可以對前者進行類型安全檢查。而對后者只進行字符替換，沒有類型安全檢查，并且在字符替換可能會產(chǎn)生意料不到的錯誤。
2） 有些集成化的調(diào)試工具可以對const 常量進行調(diào)試，但是不能對宏常量進行調(diào)試。

10.簡述數(shù)組與指針的區(qū)別？
數(shù)組要么在靜態(tài)存儲區(qū)被創(chuàng)建（如全局數(shù)組），要么在棧上被創(chuàng)建。指針可以隨時指向任意類型的內(nèi)存塊。
(1)修改內(nèi)容上的差別
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 編譯器不能發(fā)現(xiàn)該錯誤，運行時錯誤
(2) 用運算符sizeof 可以計算出數(shù)組的容量（字節(jié)數(shù)）。sizeof(p),p 為指針得到的是一個指針變量的字節(jié)數(shù)，而不是p 所指的內(nèi)存容量。C++/C 語言沒有辦法知道指針所指的內(nèi)存容量，除非在申請內(nèi)存時記住它。注意當數(shù)組作為函數(shù)的參數(shù)進行傳遞時，該數(shù)組自動退化為同類型的指針。
char a[] = “hello world”;
char *p = a;
cout<
cout<
計算數(shù)組和指針的內(nèi)存容量
voidFunc(char a[100])
{
cout<
}

11.變量的聲明和定義有什么區(qū)別？
答：聲明變量不分配空間，定義變量要分配空間。聲明主要是告訴編譯器,后面的引用都按聲明的格式。定義其實包含了聲明的意思,同時要分配內(nèi)存空間。

12. 解釋堆和棧的區(qū)別。
答：堆（heap）——一般由程序員分配釋放，若程序員不釋放，程序結(jié)束時可能由OS回收。注意它與數(shù)據(jù)結(jié)構(gòu)中的堆是兩回事，分配方式倒是類似于鏈表。速度比較慢，而且容易產(chǎn)生內(nèi)存碎片,不過用起來最方便。
棧（stack）——由編譯器自動分配釋放，存放函數(shù)的參數(shù)值，局部變量的值等。其操作方式類似于數(shù)據(jù)結(jié)構(gòu)中的棧。由系統(tǒng)自動分配，速度較快。但程序員是無法控制的。

13. const的作用是什么?
答：（1）可以定義const常量
（2）const可以修飾函數(shù)的參數(shù)、返回值，甚至函數(shù)的定義體。被const修飾的東西都受到強制保護，可以預防意外的變動，能提高程序的健壯性。

14. 下列哪兩個是等同的
int b;
A constint* a = &b; //指向常量的指針，不能通過指針改變b，但指針的地址可以改變。
B const* int a = &b;// 指針的地址不可以改變，但可以通過指針改變b的值
C constint* const a = &b; //指針指向的值，和指針本身的地址都不能改變
D intconst* const a = &b;//與c相同

15. 完成程序，實現(xiàn)對數(shù)組的降序排序
#include
void sort(int array[] );
int main()
{
int array[]={45，56，76，234，1，34，23，2，3}； //數(shù)字任//意給出
sort( array );
return 0;
}
void sort( int array[] )
{____________________________________
inti,j,k;
for(i=1;i<=7;i++) { if(array[i]>array[i-1])
{
k=ARRAY[i];
j=i-1;
do
{
array[j+1]=array[j];
j– ;
}
while(k>array[j]&&j>=0);
array[j+1]=k;
}
}
—————————————————–
}

16. int i=(j=4,k=8,l=16,m=32); printf(“%d”, i); 輸出是多少？
答：相當于 i=j=4；i=k=8；i=l=16；i=m=32; 故最后i=32；

17. 請簡述以下兩個for循環(huán)的優(yōu)缺點（5分）
1）for (i=0; i
{
if (condition)
DoSomething();
else
DoOtherthing();
}
2）if (condition)
{
for (i=0; i
DoSomething();
}
else
{
for (i=0; i 0)
{
*psTo++ = *psFrom++;
}
returnpvTo;
}

19. .C++里面如何聲明const void f(void)函數(shù)為C程序中的庫函數(shù)？
答：在該函數(shù)前添加extern “C”聲明。由于編譯后的名字不同，C++程序不能直接調(diào)用C 函數(shù)。

20. 請寫出下面代碼在 32 位平臺上的運行結(jié)果，并說明sizeof的性質(zhì)：
#include
#include
int main(void)
{
char a[30];
char *b = (char *)malloc(20 * sizeof(char));
printf(“%d\n”, sizeof(a));
printf(“%d\n”, sizeof(b));
printf(“%d\n”, sizeof(a[3]));
printf(“%d\n”, sizeof(b+3));
printf(“%d\n”, sizeof(*(b+4)));
return 0 ;
}
答：在32位系統(tǒng)下（如WIN32），指針長度為32位。a是一個有30個元素的字符型數(shù)組；b是一個字符串指針；a[3]是字符型；b+3是指針；*(b+4)是字符型。
因此輸出： 30、4、1、4、1

21. C++中，關鍵字struct和class的區(qū)別僅僅在于：
struct定義的類的缺省成員為公有的，而class定義的類的缺省成員為私有的;

22. 頭文件的作用是什么?
答：1）通過頭文件來調(diào)用庫功能。2）頭文件能加強類型安全檢查。

23. C++函數(shù)中值的傳遞方式有哪幾種?
答：C++函數(shù)的三種傳遞方式為：值傳遞、指針傳遞和引用傳遞。

24. 內(nèi)存的分配方式的分配方式有幾種?
答：1）從靜態(tài)存儲區(qū)域分配。內(nèi)存在程序編譯的時候就已經(jīng)分配好，這塊內(nèi)存在程序的整個運行期間都存在。例如全局變量。
2）在棧上創(chuàng)建。在執(zhí)行函數(shù)時，函數(shù)內(nèi)局部變量的存儲單元都可以在棧上創(chuàng)建，函數(shù)執(zhí)行結(jié)束時這些存儲單元自動被釋放。棧內(nèi)存分配運算內(nèi)置于處理器的指令集中，效率很高，但是分配的內(nèi)存容量有限。
3）從堆上分配，亦稱動態(tài)內(nèi)存分配。程序在運行的時候用malloc或new申請任意多少的內(nèi)存，程序員自己負責在何時用free或delete釋放內(nèi)存。動態(tài)內(nèi)存的生存期由我們決定，使用非常靈活，但問題也最多。

25. 設計函數(shù)intatoi(char *s)。
答：intatoi (char *s)
{
int i = 0,sum = 0,sign; //輸入的數(shù)前面可能還有空格或制表符應加判斷
while(*s==”||*s==’\t’)
{
i++;
}
sign = (*s==’-')?-1:1;
if(*s==’-'|| *s==’+')
{
i++;
}
while(*s!=’\0′)
{
sum = *s-’0′+sum*10;
i++;
}
return sign*sum;
}

26. 編寫strcat函數(shù)(6分)
已知strcat函數(shù)的原型是char *strcat (char *strDest, const char *strSrc);
其中strDest是目的字符串，strSrc是源字符串。
（1）不調(diào)用C++/C 的字符串庫函數(shù)，請編寫函數(shù)strcat
答：
char * __cdeclstrcat(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 */
}
（2）strcat能把strSrc的內(nèi)容連接到strDest，為什么還要char * 類型的返回值？
答：方便賦值給其他變量。

27. MFC中CString是類型安全類么？
答：不是，其它數(shù)據(jù)類型轉(zhuǎn)換到CString可以使用CString的成員函數(shù)Format來轉(zhuǎn)換

28.函數(shù)模板與類模板有什么區(qū)別？
答：函數(shù)模板的實例化是由編譯程序在處理函數(shù)調(diào)用時自動完成的，而類模板的實例化必須由程序員在程序中顯式地指定。

29. 寫一個“標準”宏MIN，這個宏輸入兩個參數(shù)并返回較小的一個。
答：#define MIN(A,B) ((A) <= (B) ? (A) : (B)) 宏的副作用（與某些函數(shù)的混淆）：least = MIN(*p++, b)。宏定義#define MIN(A,B) ((A) <= (B) ? (A) : (B))對MIN(*p++, b)的作用結(jié)果是：

((*p++) <= (b) ? (*p++) : (*p++))

30. 嵌入式系統(tǒng)中經(jīng)常要用到無限循環(huán)，你怎么樣用C編寫死循環(huán)呢？
答：while(1){}或者for(;;)

31. 用變量a給出下面的定義
a) 一個整型數(shù)（An integer）
b) 一個指向整型數(shù)的指針（A pointer to an integer）
c) 一個指向指針的的指針，它指向的指針是指向一個整型數(shù)（A pointer to a pointer to an integer）
d) 一個有10個整型數(shù)的數(shù)組（An array of 10 integers）
e) 一個有10個指針的數(shù)組，該指針是指向一個整型數(shù)的（An array of 10 pointers to integers）
f) 一個指向有10個整型數(shù)數(shù)組的指針（A pointer to an array of 10 integers）
g) 一個指向函數(shù)的指針，該函數(shù)有一個整型參數(shù)并返回一個整型數(shù)（A pointer to a function that takes an integer as an argument and returns an integer）
h) 一個有10個指針的數(shù)組，該指針指向一個函數(shù)，該函數(shù)有一個整型參數(shù)并返回一個整型數(shù)（ An array of ten pointers to functions that take an integer argument and return an integer ）
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

32. 1）關鍵字static的作用是什么？答：（1）用于全局變量；（2）用于局部變量；（3）用于函數(shù)。
2）關鍵字const有什么含意？答：表示常量不可以修改的變量。

33. 如何判斷一段程序是由C 編譯程序還是由C++編譯程序編譯的？
答案：#ifdef __cplusplus
cout<<"c++";
#else
cout<<"c";
#endif

34. 數(shù)組a[N]，存放了1至N-1個數(shù)，其中某個數(shù)重復一次。寫一個函數(shù)，找出被重復的數(shù)字.時間復雜度必須為o（N）函數(shù)原型：intdo_dup(int a[],int N)
答案：如果數(shù)就是1－N-1,那么求出a[N]的和，然后減去1－N-1就行了。(確定數(shù)字1-N)
S = N * (N-1) / 2;
int i;
int s = 0;
for(i=0;i<>
{
s += a[i];
}
int res = s – S;

35. 程序由多個模塊組成，所有模塊都使用一組標準的包含文件和相同的編譯選項。在這種情況下，可以將所有包含文件預編譯為一個預編譯頭。
char * const p;
charconst * p
const char *p
上述三個有什么區(qū)別？
答：char * const p; //常量指針，p的值不可以修改
char const * p；//指向常量的指針，指向的常量值不可以改
const char *p； //和char const *p

36. 有1,2,….一直到n的無序數(shù)組,求排序算法,并且要求時間復雜度為O(n),空間復雜度O(1),使用交換,而且一次只能交換兩個數(shù)。
#include
int main()
{
int a[] = {10,6,9,5,2,8,4,7,1,3};
intlen = sizeof(a) / sizeof(int);
int temp;
for(int i = 0; i
{
temp = a[a[i] – 1];
a[a[i] – 1] = a[i];
a[i] = temp;
if ( a[i] == i + 1)
i++;
}
for (int j = 0; j
cout<<><>
return 0;
}

37. 寫一個函數(shù)比較兩個字符串str1和str2的大小，若相等返回0，若str1大于str2返回1，若str1小于str2返回－1
intstrcmp ( const char * src,const char * dst)
{
int ret = 0 ;
while( ! (ret = *(unsigned char *)src – *(unsigned char *)dst) && *dst)//字符之差為整型
{
++src;
++dst;
}
if ( ret < 0 ) ret = -1 ; else if ( ret > 0 )
ret = 1 ;
return( ret );
}

38. 用預處理指令#define 聲明一個常數(shù)，用以表明1年中有多少秒（忽略閏年問題）
答： #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL

39.Typedef在C語言中頻繁用以聲明一個已經(jīng)存在的數(shù)據(jù)類型的同義字。也可以用預處理器做類似的事。例如，思考一下下面的例子：
#definedPSstruct s *
typedefstruct s * tPS;
以上兩種情況的意圖都是要定義dPS和tPS作為一個指向結(jié)構(gòu)s指針。哪種方法更好呢？（如果有的話）為什么？
答：typedef更好。思考下面的例子：
dPS p1,p2;tPS p3,p4;
第一個擴展為：struct s * p1, p2;
上面的代碼定義p1為一個指向結(jié)構(gòu)的指，p2為一個實際的結(jié)構(gòu)，這也許不是你想要的。第二個例子正確地定義了p3 和p4 兩個指針。

40. C語言同意一些令人震驚的結(jié)構(gòu),下面的結(jié)構(gòu)是合法的嗎，如果是它做些什么？
int a = 5, b = 7, c;
c = a+++b;
答：上面的代碼被處理成：c = a++ + b;因此, 這段代碼持行后a = 6, b = 7, c = 12。

41. char* ss = “0123456789″;
sizeof(ss) 結(jié)果 4 //ss是指向字符串常量的字符指針
sizeof(*ss) 結(jié)果 1 //*ss是第一個字符
char ss[] = “0123456789″;
sizeof(ss) 結(jié)果 11 //ss是數(shù)組，計算到\0位置，因此是10＋1
sizeof(*ss) 結(jié)果 1 //*ss是第一個字符
char ss[100] = “0123456789″;
sizeof(ss) 結(jié)果是100 //ss表示在內(nèi)存中的大小 100×1
intss[100] = “0123456789″;
sizeof(ss) 結(jié)果 400 //ss表示再內(nèi)存中的大小 100×4
char q[]=”abc”;
char p[]=”a\n”;
sizeof(q),sizeof(p),strlen(q),strlen(p); 　　結(jié)果是 4 3 3 2

42.冒泡法：//從小到大排序，比較n次，每次拿一個從頭比到尾
void bubble_sort(int array[],int n)
{
inti,j,temp;
for(i = 0; i < n-1; i++)
{
for(j = 0; j < n-1-i; j++) 　　 { 　　 if(array[j] > array[j+1])
{ temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; }
}
printf(“%d “, array[j]);
}
return;
}
選擇排序法：
main()
{
　　int a[10];
　　inti,j,t,k;
for ( i = 0; i < 10; i ++ )
scanf(“%d”,&a[ i ]); //輸入10個數(shù)
　　for ( i = 0; i < 9; i ++ )
{
k = i;
　　for ( j = i + 1; j < 10; j ++) 　　if ( a[ k ] > a[ j ] )
k = j; //前進
　　if （k！=i）
　　 { t = a[ i ]; a[ i ] = a[ k ]; a[ k ] = t; }/* t 發(fā)放獎品*/
　　}
for( i = 9; i >= 0; i –)
printf(“%4d”,a[ i ]); /*顯示排序后的結(jié)果*/
}