c/c++經典面試試題及標準答案

lostinai發表於2014-05-27
C++面試

   

c/c++經典面試試題及標準答案
下面的問題我想大部分c/c++ 程式設計師 都遇見過，原文出自林銳博士的《高質量c/c++程式設計》，這本書非常好，我當初面試時從中受益頗多，不知道大家看過沒有，如果沒有看過，我特別推薦一下。 
一、請填寫BOOL , float,指標變數與“零值”比較的 if 語句。（10分）
 
請寫出 BOOL flag與“零值”比較的 if語句。（3分）
標準答案：
    if ( flag )
    if ( !flag )
如下寫法均屬不良風格，不得分。
    if (flag == TRUE)  
    if (flag == 1 )    
    if (flag == FALSE) 
        if (flag == 0)
請寫出 float x 與“零值”比較的 if語句。（4分）
標準答案示例：
const float EPSINON = 0.00001;
if ((x >= - EPSINON) && (x <= EPSINON)
不可將浮點變數用“==”或“！=”與數字比較，應該設法轉化成“>=”或“<=”此類形式。
如下是錯誤的寫法，不得分。
    if (x == 0.0)  
    if (x != 0.0)      
請寫出 char *p 與“零值”比較的 if語句。（3分）
標準答案：
    if (p == NULL)
    if (p != NULL)
如下寫法均屬不良風格，不得分。
    if (p == 0)
    if (p != 0)    
    if (p) 
        if (!)     
二、以下為Windows NT下的32位C++程式，請計算sizeof的值（10分）
 char str[] = “Hello” ;
 char   *p = str ;
int     n = 10;
請計算
sizeof (str ) = 6   （2分）
sizeof ( p ) =   4   （2分）
sizeof ( n ) =   4   （2分）
 
void Func ( char str[100])
{
請計算
sizeof( str ) =   4     （2分）
}
void *p = malloc( 100 );
請計算
sizeof ( p ) = 4      （2分）
 
 三、簡答題（25分）
 
1、標頭檔案中的 ifndef/define/endif幹什麼用？（5分）
答：防止該標頭檔案被重複引用。
 
2、#include <filename.h>  和 #include “filename.h”有什麼區別？（5分）
答：對於#include <filename.h>，編譯器從標準庫路徑開始搜尋 filename.h
    對於#include “filename.h”，編譯器從使用者的工作路徑開始搜尋 filename.h
 
3、const有什麼用途？（請至少說明兩種）（5分）
答：（1）可以定義 const常量
（2）const可以修飾函式的引數、返回值，甚至函式的定義體。被const修飾的東西都受到強制保護，可以預防意外的變動，能提高程式的健壯性。
 
4、在C++程式中呼叫被 C編譯器編譯後的函式，為什麼要加 extern “C”？（5分）
答：C++語言支援函式過載，C語言不支援函式過載。函式被C++編譯後在庫中的名字與C語言的不同。假設某個函式的原型為： void foo(int x, int y);
該函式被C編譯器編譯後在庫中的名字為_foo，而C++編譯器則會產生像_foo_int_int之類的名字。
C++提供了C連線交換指定符號extern“C”來解決名字匹配問題。
 
5、請簡述以下兩個for迴圈的優缺點（5分）
 
for (i=0; i<N; i++)
{
if (condition)
    DoSomething();
else
    DoOtherthing();
}
優點：程式簡潔
 
缺點：多執行了N-1次邏輯判斷，並且打斷了迴圈“流水線”作業，使得編譯器不能對迴圈進行優化處理，降低了效率。
if (condition)
{
for (i=0; i<N; i++)
    DoSomething();
}
else
{
    for (i=0; i<N; i++)
    DoOtherthing();
}
優點：迴圈的效率高
 
缺點：程式不簡潔
四、有關記憶體的思考題（每小題5分，共20分）
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);  
strcpy(str, "hello world");
printf(str);
}
 
請問執行Test函式會有什麼樣的結果？
答：程式崩潰。
因為GetMemory並不能傳遞動態記憶體，
Test函式中的 str一直都是 NULL。
strcpy(str, "hello world");將使程式崩潰。
 
char *GetMemory(void)
{  
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();   
printf(str);
}
 
請問執行Test函式會有什麼樣的結果？
答：可能是亂碼。
因為GetMemory返回的是指向“棧記憶體”的指標，該指標的地址不是 NULL，但其原先的內容已經被清除，新內容不可知。
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");  
printf(str);   
}
請問執行Test函式會有什麼樣的結果？
答：
（1）能夠輸出hello
（2）記憶體洩漏
void Test(void)
{
char *str = (char *) malloc(100);
    strcpy(str, “hello”);
    free(str);    
    if(str != NULL)
    {
     strcpy(str, “world”);
printf(str);
}
}
請問執行Test函式會有什麼樣的結果？
答：篡改動態記憶體區的內容，後果難以預料，非常危險。
因為free(str);之後，str成為野指標，
if(str != NULL)語句不起作用。
 
五、編寫strcpy函式（10分）
已知strcpy函式的原型是
 char *strcpy(char *strDest, const char *strSrc);
  其中strDest是目的字串，strSrc是源字串。
（1）不呼叫C++/C的字串庫函式，請編寫函式 strcpy
char *strcpy(char *strDest, const char *strSrc);
{
    assert((strDest!=NULL) && (strSrc !=NULL)); // 2分
    char *address = strDest;                   // 2分
    while( (*strDest++ = * strSrc++) != ‘/0’ )    // 2分
       NULL ;
    return address ;                          // 2分
}
 
（2）strcpy能把strSrc的內容複製到strDest，為什麼還要char * 型別的返回值？
答：為了實現鏈式表示式。                                              // 2分
例如       int length = strlen( strcpy( strDest, “hello world”) );
 
六、編寫類String的建構函式、解構函式和賦值函式（25分）
已知類String的原型為：
    class String
    {
     public:
        String(const char *str = NULL); // 普通建構函式
        String(const String &other);        // 拷貝建構函式
        ~ String(void);                     // 解構函式
        String & operate =(const String &other);    //賦值函式
     private:
        char  *m_data;                // 用於儲存字串
    };
       請編寫String的上述4個函式。
標準答案：
 
// String的解構函式
       String::~String(void)               // 3分
{
    delete [] m_data;                     
// 由於m_data是內部資料型別，也可以寫成 delete m_data;
       }
 
       // String的普通建構函式            
       String::String(const char *str)      // 6分
{
    if(str==NULL)                         
    {
       m_data = new char[1];    // 若能加 NULL判斷則更好
       *m_data = ‘/0’;                     
    }                                         
    else
    {
       int length = strlen(str);          
       m_data = new char[length+1]; // 若能加 NULL判斷則更好     
       strcpy(m_data, str);               
    }
}  
// 拷貝建構函式
    String::String(const String &other)   // 3分
    {  
    int length = strlen(other.m_data);
    m_data = new char[length+1];      // 若能加 NULL 判斷則更好   
    strcpy(m_data, other.m_data);        
}
// 賦值函式
    String & String::operate =(const String &other)    // 13分
    {  
       // (1) 檢查自賦值                     // 4分
       if(this == &other)
           return *this;
   
// (2) 釋放原有的記憶體資源            // 3分
       delete [] m_data;
      
       // （3）分配新的記憶體資源，並複製內容 // 3分
    int length = strlen(other.m_data);
    m_data = new char[length+1];         // 若能加 NULL 判斷則更好
       strcpy(m_data, other.m_data);
      
       // （4）返回本物件的引用            // 3分
       return *this;
} 
附：
1.帶引用計數的String類的實現（摘自More Effective C++）：
template<class T>                       // template class for smart
class RCPtr {                                // pointers-to-T objects; T
public:                                            // must inherit from RCObject
  RCPtr(T* realPtr = 0);
  RCPtr(const RCPtr& rhs);
  ~RCPtr();

  RCPtr& operator=(const RCPtr& rhs);
  T* operator->() const;
  T& operator*() const;
private:
  T *pointee;
  void init();
};

class RCObject {                       // base class for reference-
public:                                          // counted objects
  void addReference();
  void removeReference();
  void markUnshareable();
  bool isShareable() const;
  bool isShared() const;
protected:
  RCObject();
  RCObject(const RCObject& rhs);
  RCObject& operator=(const RCObject& rhs);
  virtual ~RCObject() = 0;
private:
  int refCount;
  bool shareable;
};

class String {                           // class to be used by
public:                                       // application developers
  String(const char *value = "");
  const char& operator[](int index) const;
  char& operator[](int index);
private:
  // class representing string values
  struct StringValue: public RCObject {
    char *data;
    StringValue(const char *initValue);
    StringValue(const StringValue& rhs);
    void init(const char *initValue);
    ~StringValue();
  };
  RCPtr<StringValue> value;
}; 

RCPtr的實現：
template<class T>
void RCPtr<T>::init()
{
  if (pointee == 0) return;
  if (pointee->isShareable() == false) {
    pointee = new T(*pointee);
  }
  pointee->addReference();
}

template<class T>
RCPtr<T>::RCPtr(T* realPtr)
: pointee(realPtr)
{ init(); }

template<class T>
RCPtr<T>::RCPtr(const RCPtr& rhs)
: pointee(rhs.pointee)
{ init(); }

template<class T>
RCPtr<T>::~RCPtr()
{ if (pointee)pointee->removeReference(); }

template<class T>
RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs)
{
  if (pointee != rhs.pointee) {
    if (pointee) pointee->removeReference();
    pointee = rhs.pointee;
    init();
  }
return *this;
}

template<class T>
T* RCPtr<T>::operator->() const { return pointee; }

template<class T>
T& RCPtr<T>::operator*() const { return *pointee; }

RCObject 的實現：
RCObject::RCObject()
: refCount(0), shareable(true) {}

RCObject::RCObject(const RCObject&)
: refCount(0), shareable(true) {}

RCObject& RCObject::operator=(const RCObject&)
{ return *this; }

RCObject::~RCObject() {}

void RCObject::addReference() { ++refCount; }

void RCObject::removeReference()
{ if (--refCount == 0) delete this; }

void RCObject::markUnshareable()
{ shareable = false; }

bool RCObject::isShareable() const
{ return shareable; }

bool RCObject::isShared() const
{ return refCount > 1; }

String::StringValue 的實現：
void String::StringValue::init(const char *initValue)
{
  data = new char[strlen(initValue) + 1];
  strcpy(data, initValue);
}

String::StringValue::StringValue(const char *initValue)
{ init(initValue); }

String::StringValue::StringValue(const StringValue& rhs)
{ init(rhs.data); }

String::StringValue::~StringValue()
{ delete [] data; }

最後，歸結到 String，它的實現是：
String::String(const char *initValue)
: value(new StringValue(initValue)) {}

const char& String::operator[](int index) const
{ return value->data[index]; }

char& String::operator[](int index)
{
  if (value->isShared()) {
    value = new StringValue(value->data);
  }
  value->markUnshareable();
  return value->data[index];
}

2.c++中智慧指標auto_ptr的實現（摘自More Effective C++）：
template<class T>
class auto_ptr {
public:
  explicit auto_ptr(T *p = 0): pointee(p) {}

  template<class U>
  auto_ptr(auto_ptr<U>& rhs): pointee(rhs.release()) {}

  ~auto_ptr() { delete pointee; }

  template<class U>
  auto_ptr<T>& operator=(auto_ptr<U>& rhs)
  {
    if (this != &rhs) reset(rhs.release());
    return *this;
  }

  T& operator*() const { return *pointee; }
  T* operator->() const { return pointee; }
  T* get() const { return pointee; }

  T* release()
  {
 T *oldPointee = pointee;
    pointee = 0;
    return oldPointee;
  }

  void reset(T *p = 0)
  {
    if (pointee != p) {
      delete pointee;
      pointee = p;
    }
  }

  private:
    T *pointee;

  template<class U>
friend class auto_ptr<U>;
  };

相關文章