c/c++面试题

⚫请写代码打印100之内的素数，讲求效率（请做你的解法的效率分析）。
 
 Sieve of Eratosthenes
 埃拉托色尼筛选法(the Sieve of Eratosthenes)简称埃氏筛法
 

 #include <iostream>
 #include <iomanip>
 using namespace std;
 
 int main()
 {
    const int size = 100;
    bool is_prime[size + 1];
    fill(is_prime, is_prime + size + 1, true);
    for(int i = 2; i <= size; i++) {
        if(is_prime[i]) {
            cout<<setw(7)<<i;
        } else {
            continue;
        }
        
        if(i > size/i) continue;
        for(int j = i*i; j <= size; j += i) {
            is_prime[j] = false;
        }
    }
 }

⚫求m,n的最大公约数。
  欧几里得辗转相除法。

  int gcd(int x, int y)
  {
    return (!y) ? x : gcd(y, x%y);
  }

⚫下列程序是否有错误，如果有请指出。

        eg1:

    void test1()
    {
        char string[10];
        char* str1 = “0123456789″;
        strcpy( string, str1 );
    }

 

        eg2:

    void test2()
    {
        char string[10], str1[10];
        int i;
        for(i=0; i<10; i++) {
          str1[i] = 'a';
        }
        strcpy( string, str1 );
    }

         eg3:

     void test3(char* str1)
    {
        char string[10];
        if( strlen( str1 ) <= 10 ) {
          strcpy( string, str1 );
        }
     }

          答：  1）strcpy拷贝遇到‘\0’结束，拷贝包括‘\0’。而字符串str1没有结束符，当拷贝到长度为10的字符数组时，会越界。

                    2）从字符数组str1拷贝到字符数组string，拷贝的长度大于10且是未知的，因此string会越界。

                    3）strlen(str1) <= 10 应改为 strlen(str1) < 10, 因为‘\0’也要占一个字节。

⚫实现strcpy函数。   

       char* strcpy(char* dest, const char* src) 
       {
           assert((dest != NULL) && (src != NULL));
           char* ret = dest;
           while( (*dest++ = *src++) != '\0' ) ;
           return ret;
       }

⚫实现strlen函数。

             

       int strlen(const char* str)
       {
           assert(str != NULL);
           int len = 0;
           while(*str++ != '\0'){
               len++;
           }
           return len;
       }

⚫以下为Windows NT下的32位C++程序，请计算sizeof的值

       void Func(char str[100])
       {
           sizeof(str) = ?;
       }

       void* p = malloc(100);

              解答：  sizeof(str) = 4;            sizeof(p) = 4;

              剖析： 数组名作函数参数，数组会退化为指针；也失去了常量的特性，可以自增、自减等。

⚫写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？

      least = MIN(*p++, b);

      解答：      

        #define MIN(x, y) ((x) > (y) ? (y) : (x))

                ((*p++) > (b) ? (b) : (*p++)) 这个表达式会产生副作用，指针p会被两次++自增。

⚫编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”，

       函数头：

       // pStr是指向以'\0'结尾的字符串指针

       // steps是要求移动的n

       void LoopMove(char* pStr, int steps)

       {

               // Code here;

       }

       解答:

   方法-：
   void LoopMove(char* pStr, int steps)
   {
       assert(pStr != NULL);
       int len = strlen(pStr);
       steps = len % steps; 
       char* tmp = malloc(len + 1);
       strcpy(tmp, pStr),
       strncpy(pStr + steps, tmp, len - steps);
       strncpy(pStr, tmp + len - steps, steps);
       free(tmp);
   }

   方法二：
   void LoopMove(char* pStr, int steps)
   {
       assert(pStr != NULL);
       int len = strlen(pStr);
       char tmp[len + 1] = {0};
       memcpy(tmp, pStr + len - steps, steps);
 //      memcpy(tmp + steps, pStr, len - steps);
 //      memcpy(pStr, tmp, len);
       memcpy(pStr + steps, pStr, len - steps);
       memcpy(pStr, tmp, steps);
   }

⚫编写类String的构造函数、析构函数和赋值函数。

      解答：

     class String {
     private :
        char* _data;
    public :
         ~String();
         String(const char* str = NULL);
         String(const String& other);
         String& operate=(const String& other);
    };

     String::~String()
     {
         if(_data != NULL) {
            delete[] _data;
            _data = NULL;
         }
     }

     String::String(const char* str = NULL)
     {
         if(str == NULL) {
            _data = new char[1];
            _data = '\0';
         } else {
            // _data may not NULL;
            _data = new char[strlen(str) + 1];
            strcpy(_data, str);
         }
     }

     String::String(const String& other)
     {
         _data = new char[strlen(other._data) + 1];
         strcpy(_data, other._data);
     }

     String& String::operate=(const String& other)
     {
         if(this == &other) {
             return *this;
         }
         delete[] _data;
         _data = new char[strlen(other._data) + 1];
         strcpy(_data, other._data);
         return *this;
     }

⚫请说出static和const关键字的作用。

      解答：   static作用：

                                    1）函数体内static变量的作用范围为该函数体；

                                    2）在模块内static全局变量可以被模块内所有的函数访问，但不能被模块外的函数访问；

                                    3）在模块内的static函数只能被该模块其他函数调用，这个函数的使用范围被限制在声明他的模块内；

                                    4）在类中的static成员变量属于整个类，对类的所有对象只有一份拷贝；

                                    5）在类中的static成员函数属于整个类，这个函数不接收this指针，因而只能访问static成员变量。

                      const作用：

                                    1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；

                                     2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；

                                    3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；

                                    4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；

                                    5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：const classA operator*(const classA& a1,const classA& a2);

                 

⚫写一个C函数，若处理器是big_endian，返回0，否则返回1.

            解答：

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

⚫写一个函数返回1+2+3+...+n的值（假定结构不超长）

            解答：      

      int Sum(int n)
      {
          return ((long)n + 1) * n / 2;
      }