徹底合併C++面試題

C++面試題

1.是否是父母寫了virtual 功能，假設子類重寫它的功能不virtual ,也使多態性?

virtual修飾符隱形遺傳。

private 還集成。問權限而已

virtual可加可不加

子類的空間裏有父類的所有變量(static除外)

同一個函數僅僅存在一個實體(inline除外)

子類覆蓋它的函數不加virtual ,也能實現多態。

在子類的空間裏，有父類的私有變量。私有變量不能直接訪問。

--------------------------------------------------------------------------
2.輸入一個字符串。將其逆序後輸出。

（使用C++，不建議用僞碼）

#include <iostream>
using namespace std;

void main()
{
  char a[50];memset(a,0,sizeof(a));
  int i=0,j;
  char t;
  cin.getline(a,50,'/n');
  for(i=0,j=strlen(a)-1;i<strlen(a)/2;i++,j--)
  {
   t=a[i];
      a[i]=a[j];
   a[j]=t;
  }
  cout<<a<<endl; 
}

//另一種

string str;
cin>>str;
str.replace;
cout<<str;

--------------------------------------------------------------------------
3.請簡單描寫敘述Windows內存管理的方法。

內存管理是操做系統中的重要部分，兩三句話恐怕誰也說不清楚吧～～
我先說個大概，但願能夠拋磚引玉吧

當程序執行時需要從內存中讀出這段程序的代碼。代碼的位置必須在物理內存中才幹被執行，由於現在的操做系統中有許多的程序執行着，內存中不能夠全然放下，因此引出了虛擬內存的概念。

把哪些不常用的程序片段就放入虛擬內存。當需要用到它的時候在load入主存（物理內存）中。

這個就是內存管理所要作的事。內存管理還有另一件事需要作：計算程序片斷在主存中的物理位置，以便CPU調度。

內存管理有塊式管理，頁式管理，段式和段頁式管理。現在常用段頁式管理

塊式管理：把主存分爲一大塊、一大塊的。當所需的程序片段不在主存時就分配一塊主存空間。把程 序片段load入主存，就算所需的程序片度僅僅有幾個字節也僅僅能把這一塊分配給它。

這樣會形成很是大的浪費，平均浪費了50％的內存空間，但時易於管理。

頁式管理：把主存分爲一頁一頁的。每一頁的空間要比一塊一塊的空間小很是多。顯然這樣的方法的空間利用率要比塊式管理高很是多。

段式管理：把主存分爲一段一段的，每一段的空間又要比一頁一頁的空間小很是多，這樣的方法在空間利用率上又比頁式管理高很是多。但是也有另一個缺點。一個程序片段可能會被分爲幾十段，這樣很是多時間就會被浪費在計算每一段的物理地址上（計算機最耗時間的你們都知道是I/O吧）。

段頁式管理：結合了段式管理和頁式管理的優勢。

把主存分爲若干頁，每一頁又分爲若干段。優勢就很是明顯，不用我多說了吧。

各類內存管理都有它本身的方法來計算出程序片段在主存中的物理地址。事實上都很是相似。

這僅僅是一個大概而已，不足以說明內存管理的皮毛。無論哪一本操做系統書上都有具體的解說

--------------------------------------------------------------------------
4.
#include "stdafx.h"
#define SQR(X) X*X

int main(int argc, char* argv[])
{
 int a = 10;
 int k = 2;
 int m = 1;

 a /= SQR(k+m)/SQR(k+m);
 printf("%d/n",a);

 return 0;
}
這道題目的結果是什麼啊?

define 僅僅是定義而已，在編擇時僅僅是簡單代換X*X而已。並不通過算術法則的

a /= (k+m)*(k+m)/(k+m)*(k+m);
=>a /= (k+m)*1*(k+m);
=>a = a/9;
=>a = 1;

--------------------------------------------------------------------------
5.
const 符號常量。
(1)const char *p
(2)char const *p
(3)char * const p
說明上面三種描寫敘述的差異；

假設const位於星號的左側。則const就是用來修飾指針所指向的變量，即指針指向爲常量；
假設const位於星號的右側，const就是修飾指針自己，即指針自己是常量。

(1)const char *p

一個指向char類型的const對象指針。p不是常量,咱們可以改動p的值，使其指向不一樣的char。但是不能改變它指向非char對象，如：
const char *p;
char c1='a';
char c2='b';
p=&c1;//ok
p=&c2;//ok
*p=c1;//error

(2)char const *p
(3)char * const p

這兩個好象是同樣的。此時*p可以改動，而p不能改動。

(4)const char * const p
這樣的是地址及指向對象都不能改動。

--------------------------------------------------------------------------
6.如下是C語言中兩種if語句推斷方式。請問哪一種寫法更好？爲何？
 int n;
 if (n == 10) // 第一種推斷方式
 if (10 == n) // 另一種推斷方式

假設少了個=號,編譯時就會報錯,下降了出錯的可能行,可以檢測出是否少了=

--------------------------------------------------------------------------
7.如下的代碼有什麼問題？
void DoSomeThing(...)
{
 char* p;
 ...
 p = malloc(1024);  // 分配1K的空間
 if (NULL == p)
  return;
 ...
 p = realloc(p, 2048); // 空間不夠。又一次分配到2K
 if (NULL == p)
  return;
 ...
}

A:
p = malloc(1024);     應該寫成： p = (char *) malloc(1024);
        沒有釋放p的空間。形成內存泄漏。

--------------------------------------------------------------------------
8.如下的代碼有什麼問題？並請給出正確的寫法。
void DoSomeThing(char* p)
{
 char str[16];
 int n;
 assert(NULL != p);
 sscanf(p, "%s%d", str, n);
 if (0 == strcmp(str, "something"))
 {
  ...
 }
}

A:
sscanf(p, "%s%d", str, n);   這句該寫成： sscanf(p, "%s%d", str, &n);

--------------------------------------------------------------------------
9.如下代碼有什麼錯誤?
Void test1()
{
 char string[10];
 char *str1="0123456789";
 strcpy(string, str1);
}

數組越界

--------------------------------------------------------------------------
10.如下代碼有什麼問題?
Void test2()
{
  char string[10], str1[10];
  for(i=0; i<10;i++)
  {
     str1[i] ='a';
  }
  strcpy(string, str1);
}

數組越界

--------------------------------------------------------------------------
11.如下代碼有什麼問題?
Void test3(char* str1)
{
  char string[10];
  if(strlen(str1)<=10)
  {
    strcpy(string, str1);
  }
}

==數組越界
==strcpy拷貝的結束標誌是查找字符串中的/0 所以假設字符串中沒有遇到/0的話 會一直複製。直到遇到/0,上面的123都所以產生越界的狀況
 
建議使用 strncpy 和 memcpy

--------------------------------------------------------------------------
12.如下代碼有什麼問題?

#define MAX_SRM 256

DSN get_SRM_no()
{
  static int SRM_no; //是否是這裏沒賦初值？
  int I;
  for(I=0;I<MAX_SRM;I++,SRM_no++)
  {
    SRM_no %= MAX_SRM;
    if(MY_SRM.state==IDLE)
    {
      break;
    }
  }
  if(I>=MAX_SRM)
    return (NULL_SRM);
  else
    return SRM_no;
}

系統會初始化static int變量爲0,但該值會一直保存,所謂的不可重入...

--------------------------------------------------------------------------
13.寫出執行結果:
{// test1
    char str[] = "world"; cout << sizeof(str) << ": ";
    char *p    = str;     cout << sizeof(p) << ": ";
    char i     = 10;      cout << sizeof(i) << ": ";
    void *pp   = malloc(10);  cout << sizeof(p) << endl;
}

6：4：1：4

--------------------------------------------------------------------------
14.寫出執行結果:
{// test2
    union V {
 struct X {
  unsigned char s1:2;
  unsigned char s2:3;
  unsigned char s3:3;
 } x;

 unsigned char c;
    } v;

    v.c = 100;
    printf("%d", v.x.s3);

}

3

--------------------------------------------------------------------------
15.用C++寫個程序，怎樣推斷一個操做系統是16位仍是32位的？不能用sizeof()函數

A1:
16位的系統下，
int i = 65536;
cout << i; // 輸出0。
int i = 65535;
cout << i; // 輸出-1。

32位的系統下。
int i = 65536;
cout << i; // 輸出65536；
int i = 65535;
cout << i; // 輸出65535；

A2:

int a = ~0;
if( a>65536 )
{
    cout<<"32 bit"<<endl;
}
else
{
    cout<<"16 bit"<<endl;
}

--------------------------------------------------------------------------
16.C和C++有什麼不一樣?

從機制上：c是面向過程的（但c也可以編寫面向對象的程序）；c++是面向對象的，提供了類。但是，
c++編寫面向對象的程序比ceasy

從適用的方向：c適合要求代碼體積小的。效率高的場合，如嵌入式；c++適合更上層的，複雜的；  llinux核心大部分是c寫的。因爲它是系統軟件，效率要求極高。

從名稱上也可以看出，c++比c多了+，說明c++是c的超集；那爲何不叫c+而叫c++呢，是因爲c++比
c來講擴充的東西太多了，因此就在c後面放上兩個+。因而就成了c++

C語言是結構化編程語言，C++是面向對象編程語言。
C++側重於對象而不是過程，側重於類的設計而不是邏輯的設計。

--------------------------------------------------------------------------
17.在不用第三方參數的狀況下，交換兩個參數的值
#include <stdio.h>

void main()
{
        int i=60;
        int j=50;
        i=i+j;
        j=i-j;
        i=i-j;
        printf("i=%d/n",i);
        printf("j=%d/n",j);
}

方法二：
i^=j;
j^=i;
i^=j;

方法三：
// 用加減實現。而且不會溢出
a = a+b-(b=a)

--------------------------------------------------------------------------
18.有關位域的面試題（爲何輸出的是一個奇怪的字符）

a.t = 'b';效果至關於 a.t= 'b' & 0xf;

'b' --> 01100010
'b' & 0xf -->>00000010
因此輸出Ascii碼爲2的特殊字符

char t:4;就是4bit的字符變量。相同
unsigned short i:8;就是8bit的無符號短整形變量

--------------------------------------------------------------------------
19.int i=10, j=10, k=3; k*=i+j; k最後的值是?

60

--------------------------------------------------------------------------
20.進程間通訊的方式有?

進程間通訊的方式有 共享內存， 管道 ，Socket ，消息隊列 , DDE等

--------------------------------------------------------------------------
21.
struct A
{
char t:4;
char k:4;
unsigned short i:8;
unsigned long m;
}
sizeof(A)=?（不考慮邊界對齊）

7

struct CELL             // Declare CELL bit field
{
   unsigned character  : 8;  // 00000000 ????

?

?

?

?
   unsigned foreground : 3;  // 00000?

?? 00000000
   unsigned intensity  : 1;  // 0000?000 00000000
   unsigned background : 3;  // 0?

?

?

0000 00000000
   unsigned blink      : 1;  // ?0000000 00000000
} screen[25][80];       // Array of bit fields
2、位結構
    位結構是一種特殊的結構, 在需按位訪問一個字節或字的多個位時, 位結構
比按位運算符更加方便。
    位結構定義的通常形式爲:
     struct位結構名{
          數據類型 變量名: 整型常數;
          數據類型 變量名: 整型常數;
     } 位結構變量;
    當中: 數據類型必須是int(unsigned或signed)。 整型常數必須是非負的整
數, 範圍是0~15, 表示二進制位的個數, 即表示有多少位。
    變量名是選擇項, 可以不命名, 這樣規定是爲了排列需要。
    好比: 如下定義了一個位結構。
     struct{
          unsigned incon: 8;  /*incon佔用低字節的0~7共8位*/
          unsigned txcolor: 4;/*txcolor佔用高字節的0~3位共4位*/
          unsigned bgcolor: 3;/*bgcolor佔用高字節的4~6位共3位*/
          unsigned blink: 1;  /*blink佔用高字節的第7位*/
     }ch;
    位結構成員的訪問與結構成員的訪問一樣。
    好比: 訪問上例位結構中的bgcolor成員可寫成:
      ch.bgcolor
 
    注意:
    1. 位結構中的成員可以定義爲unsigned, 也可定義爲signed,  但當成員長
度爲1時, 會被以爲是unsigned類型。因爲單個位不可能具備符號。
    2. 位結構中的成員不能使用數組和指針, 但位結構變量可以是數組和指針,
假設是指針, 其成員訪問方式同結構指針。

    3. 位結構總長度(位數), 是各個位成員定義的位數之和,  可以超過兩個字
節。
    4. 位結構成員可以與其餘結構成員一塊兒使用。
    好比:
     struct info{
          char name[8];
          int age;
          struct addr address;
          float pay;
          unsigned state: 1;
          unsigned pay: 1;
          }workers;
    上例的結構定義了關於一個工人的信息。

當中有兩個位結構成員, 每個位結
構成員僅僅有一位, 所以僅僅佔一個字節但保存了兩個信息, 該字節中第一位表示工
人的狀態, 第二位表示工資是否已發放。

因而可知使用位結構可以節省存貯空間。

--------------------------------------------------------------------------
22.如下的函數實現在一個固定的數上加上一個數，有什麼錯誤，改正
int add_n(int n)
{
  static int i=100;
  i+=n;
  return i;
}

答:
因爲static使得i的值會保留上次的值。
去掉static就可了

--------------------------------------------------------------------------
23.如下的代碼有什麼問題?

class A
{
public:
  A() { p=this; }
  ~A() { if(p!=NULL) { delete p; p=NULL; } }

  A* p;
};

答:
會引發無限遞歸

--------------------------------------------------------------------------
24.
union a {
 int a_int1;
 double a_double;
 int a_int2;
};

typedef struct
{
 a a1;
 char y;
} b;

class c
{
 double c_double;
 b b1;
 a a2;

};

輸出cout<<sizeof(c)<<endl;的結果?

答:
VC6環境下得出的結果是32

另:
我(sun)在VC6.0+win2k下作過試驗:
short - 2
int-4
float-4
double-8
指針-4

sizeof(union)，以結構裏面size最大的爲union的size

解析C語言中的sizeof

1、sizeof的概念　
　　sizeof是C語言的一種單目操做符，如C語言的其它操做符++、--等。

它並不是函數。

sizeof操做符以字節形式給出了其操做數的存儲大小。操做數可以是一個表達式或括在括號內的類型名。

操做數的存儲大小由操做數的類型決定。　

2、sizeof的用法　
　　一、用於數據類型　

　　sizeof使用形式：sizeof（type）　

　　數據類型必須用括號括住。如sizeof（int）。　

　　二、用於變量　

　　sizeof使用形式：sizeof（var_name）或sizeof　var_name　

　　變量名可以不用括號括住。

如sizeof　(var_name)，sizeof　var_name等都是正確形式。

帶括號的使用方法更廣泛，大多數程序猿採用這樣的形式。　

　　注意：sizeof操做符不能用於函數類型。不全然類型或位字段。不全然類型指具備未知存儲大小的數據類型，如未知存儲大小的數組類型、未知內容的結構或聯合類型、void類型等。　

　　如sizeof(max)若此時變量max定義爲int　max(),sizeof(char_v)　若此時char_v定義爲char　char_v　[MAX]且MAX未知，sizeof(void)都不是正確形式。　

3、sizeof的結果　
　　sizeof操做符的結果類型是size_t，它在頭文件

中typedef爲unsigned　int類型。

該類型保證能容納實現所創建的最大對象的字節大小。　

　　一、若操做數具備類型char、unsigned　char或signed　char。其結果等於1。　

　　ANSI　C正式規定字符類型爲1字節。

　

　　二、int、unsigned　int　、short　int、unsigned　short　、long　int　、unsigned　long　、float、double、long　double類型的sizeof　在ANSI　C中沒有詳細規定。大小依賴於實現，通常可能分別爲二、二、二、二、四、四、四、八、10。　

　　三、當操做數是指針時，sizeof依賴於編譯器。好比Microsoft　C/C++7.0中，near類指針字節數爲2，far、huge類指針字節數爲4。通常Unix的指針字節數爲4。　

　　四、當操做數具備數組類型時。其結果是數組的總字節數。　

　　五、聯合類型操做數的sizeof是其最大字節成員的字節數。結構類型操做數的sizeof是這樣的類型對象的總字節數，包含不論什麼墊補在內。

　

　　讓咱們看例如如下結構：　

　　struct　{char　b;　double　x;}　a;　

　　在某些機器上sizeof（a）=12，而通常sizeof（char）+　sizeof（double）=9。

　

　　這是因爲編譯器在考慮對齊問題時。在結構中插入空位以控制各成員對象的地址對齊。如double類型的結構成員x要放在被4整除的地址。

　

　　六、假設操做數是函數中的數組形參或函數類型的形參，sizeof給出其指針的大小。　

4、sizeof與其它操做符的關係　
　　sizeof的優先級爲2級，比/、%等3級運算符優先級高。它可以與其它操做符一塊兒組成表達式。如i*sizeof（int）。當中i爲int類型變量。　

5、sizeof的主要用途　
　　一、sizeof操做符的一個主要用途是與存儲分配和I/O系統那樣的例程進行通訊。

好比：　

　　void　*malloc（size_t　size）,　

　　size_t　fread(void　*　ptr,size_t　size,size_t　nmemb,FILE　*　stream)。　

　　二、sizeof的還有一個的主要用途是計算數組中元素的個數。好比：　

　　void　*　memset（void　*　s,int　c,sizeof(s)）。　

6、建議　
　　由於操做數的字節數在實現時可能出現變化。建議在涉及到操做數字節大小時用sizeof來取代常量計算。

=============================================================
本文主要包含二個部分。第一部分重點介紹在VC中。怎麼樣採用sizeof來求結構的大小。以及easy出現的問題，並給出解決這個問題的方法，第二部分總結出VC中sizeof的主要使用方法。

一、 sizeof應用在結構上的狀況

請看如下的結構：

struct MyStruct

{

double dda1;

char dda;

int type

};

對結構MyStruct採用sizeof會出現什麼結果呢？sizeof(MyStruct)爲多少呢？或許你會這樣求：

sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

但是當在VC中測試上面結構的大小時，你會發現sizeof(MyStruct)爲16。你知道爲何在VC中會得出這樣一個結果嗎？

事實上，這是VC對變量存儲的一個特殊處理。

爲了提升CPU的存儲速度，VC對一些變量的起始地址作了"對齊"處理。

在默認狀況下，VC規定各成員變量存放的起始地址相對於結構的起始地址的偏移量必須爲該變量的類型所佔用的字節數的倍數。如下列出常用類型的對齊方式(vc6.0,32位系統)。

類型
對齊方式（變量存放的起始地址相對於結構的起始地址的偏移量）

Char
偏移量必須爲sizeof(char)即1的倍數

int
偏移量必須爲sizeof(int)即4的倍數

float
偏移量必須爲sizeof(float)即4的倍數

double
偏移量必須爲sizeof(double)即8的倍數

Short
偏移量必須爲sizeof(short)即2的倍數

 

各成員變量在存放的時候依據在結構中出現的順序依次申請空間，同一時候依照上面的對齊方式調整位置。空缺的字節VC會本身主動填充。同一時候VC爲了確保結構的大小爲結構的字節邊界數（即該結構中佔用最大空間的類型所佔用的字節數）的倍數，因此在爲最後一個成員變量申請空間後。還會依據需要本身主動填充空缺的字節。

如下用前面的樣例來講明VC究竟怎麼樣來存放結構的。

struct MyStruct

{

double dda1;

char dda;

int type

}；

爲上面的結構分配空間的時候，VC依據成員變量出現的順序和對齊方式，先爲第一個成員dda1分配空間，其起始地址跟結構的起始地址一樣（恰好偏移量0恰好爲sizeof(double)的倍數）。該成員變量佔用sizeof(double)=8個字節；接下來爲第二個成員dda分配空間，這時下一個可以分配的地址對於結構的起始地址的偏移量爲8，是sizeof(char)的倍數，因此把dda存放在偏移量爲8的地方知足對齊方式，該成員變量佔用sizeof(char)=1個字節。接下來爲第三個成員type分配空間，這時下一個可以分配的地址對於結構的起始地址的偏移量爲9，不是sizeof(int)=4的倍數，爲了知足對齊方式對偏移量的約束問題。VC本身主動填充3個字節（這三個字節沒有放什麼東西）。這時下一個可以分配的地址對於結構的起始地址的偏移量爲12，恰好是sizeof(int)=4的倍數，因此把type存放在偏移量爲12的地方，該成員變量佔用sizeof(int)=4個字節；這時整個結構的成員變量已經都分配了空間，總的佔用的空間大小爲：8+1+3+4=16，恰好爲結構的字節邊界數（即結構中佔用最大空間的類型所佔用的字節數sizeof(double)=8）的倍數，因此沒有空缺的字節需要填充。

因此整個結構的大小爲：sizeof(MyStruct)=8+1+3+4=16，當中有3個字節是VC本身主動填充的，沒有放不論什麼有意義的東西。

如下再舉個樣例，交換一下上面的MyStruct的成員變量的位置，使它變成如下的狀況：

struct MyStruct

{

char dda;

double dda1;  

int type

}。

這個結構佔用的空間爲多大呢？在VC6.0環境下，可以獲得sizeof(MyStruc)爲24。結合上面提到的分配空間的一些原則，分析下VC怎麼樣爲上面的結構分配空間的。（簡單說明）

struct MyStruct

{

  char dda;//偏移量爲0，知足對齊方式，dda佔用1個字節。

double dda1;//下一個可用的地址的偏移量爲1，不是sizeof(double)=8

             //的倍數。需要補足7個字節才幹使偏移量變爲8（知足對齊

             //方式），所以VC本身主動填充7個字節，dda1存放在偏移量爲8

             //的地址上。它佔用8個字節。

int type；//下一個可用的地址的偏移量爲16。是sizeof(int)=4的倍

           //數，知足int的對齊方式，因此不需要VC本身主動填充，type存

           //放在偏移量爲16的地址上，它佔用4個字節。

}；//所有成員變量都分配了空間。空間總的大小爲1+7+8+4=20，不是結構

   //的節邊界數（即結構中佔用最大空間的類型所佔用的字節數sizeof

   //(double)=8）的倍數，因此需要填充4個字節，以知足結構的大小爲

   //sizeof(double)=8的倍數。

 

因此該結構總的大小爲：sizeof(MyStruc)爲1+7+8+4+4=24。當中總的有7+4=11個字節是VC本身主動填充的，沒有放不論什麼有意義的東西。

 

VC對結構的存儲的特殊處理確實提升CPU存儲變量的速度。但是有時候也帶來了一些麻煩，咱們也屏蔽掉變量默認的對齊方式，本身可以設定變量的對齊方式。

VC中提供了#pragma pack(n)來設定變量以n字節對齊方式。n字節對齊就是說變量存放的起始地址的偏移量有兩種狀況：第1、假設n大於等於該變量所佔用的字節數，那麼偏移量必須知足默認的對齊方式，第2、假設n小於該變量的類型所佔用的字節數，那麼偏移量爲n的倍數，不用知足默認的對齊方式。

結構的總大小也有個約束條件，分如下兩種狀況：假設n大於所有成員變量類型所佔用的字節數，那麼結構的總大小必須爲佔用空間最大的變量佔用的空間數的倍數；

不然必須爲n的倍數。

如下舉例說明其使用方法。

#pragma pack(push) //保存對齊狀態

#pragma pack(4)//設定爲4字節對齊

struct test

{

  char m1;

  double m4;

  int  m3;

};

#pragma pack(pop)//恢復對齊狀態

以上結構的大小爲16，如下分析其存儲狀況，首先爲m1分配空間，其偏移量爲0，知足咱們本身設定的對齊方式（4字節對齊），m1佔用1個字節。

接着開始爲m4分配空間。這時其偏移量爲1，需要補足3個字節，這樣使偏移量知足爲n=4的倍數（因爲sizeof(double)大於n）,m4佔用8個字節。接着爲m3分配空間。這時其偏移量爲12，知足爲4的倍數，m3佔用4個字節。這時已經爲所有成員變量分配了空間。共分配了16個字節，知足爲n的倍數。

假設把上面的#pragma pack(4)改成#pragma pack(16)，那麼咱們可以獲得結構的大小爲24。（請讀者本身分析）

二、 sizeof使用方法總結

在VC中。sizeof有着不少的使用方法，而且很是easy引發一些錯誤。

如下依據sizeof後面的參數對sizeof的使用方法作個總結。

A．  參數爲數據類型或者爲通常變量。好比sizeof(int),sizeof(long)等等。這樣的狀況要注意的是不一樣系統系統或者不一樣編譯器獲得的結果多是不一樣的。好比int類型在16位系統中佔2個字節，在32位系統中佔4個字節。

B．  參數爲數組或指針。如下舉例說明.

int a[50];  //sizeof(a)=4*50=200; 求數組所佔的空間大小

int *a=new int[50];// sizeof(a)=4; a爲一個指針。sizeof(a)是求指針

                   //的大小,在32位系統中。固然是佔4個字節。

C．  參數爲結構或類。Sizeof應用在類和結構的處理狀況是一樣的。

但有兩點需要注意，第1、結構或者類中的靜態成員不正確結構或者類的大小產生影響。因爲靜態變量的存儲位置與結構或者類的實例地址無關。

第2、沒有成員變量的結構或類的大小爲1，因爲必須保證結構或類的每一

個實例在內存中都有惟一的地址。

如下舉例說明。

Class Test{int a;static double c};//sizeof(Test)=4.

Test *s;//sizeof(s)=4,s爲一個指針。

Class test1{ };//sizeof(test1)=1;

D．  參數爲其它。

如下舉例說明。

   int func(char s[5]);

   {

     cout<<sizeof(s);//這裏將輸出4。原本s爲一個數組。但由於作爲函

                     //數的參數在傳遞的時候系統處理爲一個指針，所

                     //以sizeof(s)實際上爲求指針的大小。

     return 1;

}

sizeof(func("1234"))=4//因爲func的返回類型爲int。因此至關於

                     //求sizeof(int).

 

以上爲sizeof的基本使用方法，在實際的使用中要注意分析VC的分配變量的分配策略，這種話可以避免一些錯誤。

--------------------------------------------------------------------------
25.i最後等於多少?

int i = 1;
int j = i++;
if((i>j++) && (i++ == j)) i+=j;

答:
i = 5

--------------------------------------------------------------------------
26.
unsigned short array[]={1,2,3,4,5,6,7};
int i = 3;
*(array + i) = ?

答:
4

--------------------------------------------------------------------------
27.
class A
{
  virtual void func1()；
  void func2();
}
Class B: class A
{
  void func1(){cout << "fun1 in class B" << endl;}
  virtual void func2(){cout << "fun2 in class B" << endl;}
}
A, A中的func1和B中的func2都是虛函數.
B, A中的func1和B中的func2都不是虛函數.
C, A中的func2是虛函數.。B中的func1不是虛函數.
D, A中的func2不是虛函數。B中的func1是虛函數.

答:
A

--------------------------------------------------------------------------
28.
數據庫：抽出部門，平均工資，要求按部門的字符串順序排序，不能含有"human resource"部門，

employee結構例如如下：employee_id, employee_name, depart_id,depart_name,wage

答:
select depart_name, avg(wage)
from employee
where depart_name <> 'human resource'
group by depart_name
order by depart_name

--------------------------------------------------------------------------
29.
給定例如如下SQL數據庫：Test(num INT(4)) 請用一條SQL語句返回num的最小值，但不準使用統計功能，如MIN。MAX等

答:
select top 1 num
from Test
order by num desc

--------------------------------------------------------------------------
30.
輸出如下程序結果。

#include <iostream.h>

class A
{
public:
 virtual void print(void)
 {
    cout<<"A::print()"<<endl;
 }
};
class B:public A
{
public:
 virtual void print(void)
 {
   cout<<"B::print()"<<endl;
 };
};
class C:public B
{
public:
 virtual void print(void)
 {
  cout<<"C::print()"<<endl;
 }
};
void print(A a)
{
   a.print();
}
void main(void)
{
   A a, *pa,*pb,*pc;
   B b;
   C c;
  
   pa=&a;
   pb=&b;
   pc=&c;
  
   a.print();
   b.print();
   c.print();
  
   pa->print();
   pb->print();
   pc->print();
  
   print(a);
   print(b);
   print(c);
}

A:
A::print()
B::print()
C::print()
A::print()
B::print()
C::print()
A::print()
A::print()
A::print()

--------------------------------------------------------------------------
31.
試編寫函數推斷計算機的字節存儲順序是開序(little endian)仍是降序(bigendian)

答:
bool IsBigendian()
{
 unsigned short usData = 0x1122;
 unsigned char  *pucData = (unsigned char*)&usData;

 return (*pucData == 0x22);
}

--------------------------------------------------------------------------
32.簡述Critical Section和Mutex的不一樣點

答:
對幾種同步對象的總結
1.Critical Section
A.速度快
B.不能用於不一樣進程
C.不能進行資源統計(每次僅僅可以有一個線程對共享資源進行存取)

2.Mutex
A.速度慢
B.可用於不一樣進程
C.不能進行資源統計

3.Semaphore
A.速度慢
B.可用於不一樣進程
C.可進行資源統計(可以讓一個或超過一個線程對共享資源進行存取)

4.Event
A.速度慢
B.可用於不一樣進程
C.可進行資源統計

 

--------------------------------------------------------------------------
33.一個數據庫中有兩個表:
一張表爲Customer。含字段ID,Name;
一張表爲Order。含字段ID,CustomerID（連向Customer中ID的外鍵）,Revenue；
寫出求每個Customer的Revenue總和的SQL語句。

建表
create table customer
(
ID int primary key,Name char(10)
)

go

create table [order]
(
ID int primary key,CustomerID  int foreign key references customer(id) , Revenue float
)

go

--查詢
select Customer.ID, sum( isnull([Order].Revenue,0) )
from customer full join [order]
on( [order].customerid=customer.id )
group by customer.id

--------------------------------------------------------------------------
34.請指出下列程序中的錯誤並且改動
void GetMemory(char *p){
  p=(char *)malloc(100);
}
void Test(void){
  char *str=NULL;
  GetMemory=(str);
  strcpy(str,"hello world");
  printf(str);
}

A:錯誤--參數的值改變後，不會傳回
GetMemory並不能傳遞動態內存，Test函數中的 str一直都是 NULL。
strcpy(str, "hello world");將使程序崩潰。

改動例如如下:
char *GetMemory(){
  char *p=(char *)malloc(100);
  return p;
}
void Test(void){
  char *str=NULL;
  str=GetMemory(){
  strcpy(str,"hello world");
  printf(str);
}

方法二:void GetMemory2(char **p)變爲二級指針.
void GetMemory2(char **p, int num)
{
 *p = (char *)malloc(sizeof(char) * num);
}

--------------------------------------------------------------------------
35.程序改錯
class mml
{
  private:
    static unsigned int x;
  public:
    mml(){ x++; }
    mml(static unsigned int &) {x++;}
    ~mml{x--;}
  pulic:
    virtual mon() {} = 0;
    static unsigned int mmc(){return x;}
    ......                     
 
};
class nnl:public mml
{
  private:
    static unsigned int y;
  public:
    nnl(){ x++; }
    nnl(static unsigned int &) {x++;}
    ~nnl{x--;}
  public:
    virtual mon() {};
     static unsigned int nnc(){return y;}
    ......                  
};

代碼片段:
mml* pp = new nnl;
..........
delete pp;

A:
基類的析構函數應該爲虛函數
virtual ~mml{x--;}

--------------------------------------------------------------------------
36.101個硬幣100真、1假。真假差異在於重量。請用無砝碼天平稱兩次給出真幣重仍是假幣重的結論。

答:
101個先取出2堆,
33,33
第一次稱,假設不相等,說明有一堆重或輕
那麼把重的那堆拿下來,再放另外35箇中的33
假設相等,說明假的重,假設不相等,新放上去的仍是重的話,說明假的輕(不可能新放上去的輕)

第一次稱,假設相等的話。這66個確定都是真的,從這66箇中取出35個來,與剩下的沒稱過的35個比
如下就不用說了

方法二:
第3題也可以拿A(50),B(50)比一下，同樣的話拿剩下的一個和真的比一下。
假設不同，就拿當中的一堆。比方A(50)再分紅兩堆25比一下，同樣的話就在
B(50)中。不同就在A(50)中。結合第一次的結果就知道了。

--------------------------------------------------------------------------
37.static變量和static 函數各有什麼特色？

答:
static變量：在程序執行期內一直有效。假設定義在函數外，則在編譯單元內可見，假設在函數內，在在定義的block內可見；
static函數：在編譯單元內可見；

--------------------------------------------------------------------------
38.用C 寫一個輸入的整數,倒着輸出整數的函數,要求用遞歸方法 ;

答:
void fun( int a )
{
 printf( "%d", a%10 );
 a /= 10;
 if( a <=0 )return;

 fun( a );
}

--------------------------------------------------------------------------
39.寫出程序結果:
void Func(char str[100])
{
  printf("%d/n", sizeof(str));
}

答:
4
分析:
指針長度

--------------------------------------------------------------------------
40.int id[sizeof(unsigned long)];
    這個對嗎？爲何??

答:
對
這個 sizeof是編譯時運算符，編譯時就肯定了
可以當作和機器有關的常量。

本文主要包含二個部分，第一部分重點介紹在VC中，怎麼樣採用sizeof來求結構的大小，以及easy出現的問題，並給出解決這個問題的方法。第二部分總結出VC中sizeof的主要使用方法。

一、 sizeof應用在結構上的狀況

請看如下的結構：

struct MyStruct

{

double dda1;

char dda;

int type

};

對結構MyStruct採用sizeof會出現什麼結果呢？sizeof(MyStruct)爲多少呢？或許你會這樣求：

sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

但是當在VC中測試上面結構的大小時，你會發現sizeof(MyStruct)爲16。

你知道爲何在VC中會得出這樣一個結果嗎？

事實上，這是VC對變量存儲的一個特殊處理。爲了提升CPU的存儲速度。VC對一些變量的起始地址作了"對齊"處理。在默認狀況下，VC規定各成員變量存放的起始地址相對於結構的起始地址的偏移量必須爲該變量的類型所佔用的字節數的倍數。

如下列出常用類型的對齊方式(vc6.0,32位系統)。

類型
對齊方式（變量存放的起始地址相對於結構的起始地址的偏移量）

Char
偏移量必須爲sizeof(char)即1的倍數

int
偏移量必須爲sizeof(int)即4的倍數

float
偏移量必須爲sizeof(float)即4的倍數

double
偏移量必須爲sizeof(double)即8的倍數

Short
偏移量必須sizeof(short)那2倍數

 

每個成員變量時，按照順序存儲它們出如今結構，以申請空間。同時調整位置按照上述對準。空置字節VC本身主動填寫。同時VC該結構的字節邊界大小，以確保結構的數量（也就是說，結構中佔有最大數量的字節型空間佔用）時代?/textarea>