C/C++基础面试题整理

1.sizeof

sizeof(0) == sizeof(int)
sizeof(0L) == sizeof(long)
sizeof(0LL) == sizeof(long long)

int array[5]; sizeof(array) == sizeof(int) * 5

2.大端小端

大端低字节高地址，高字节低地址；小端低字节低地址，高字节高地址（TCP/IP）采用大端

某32位数据在内存中的布局为（左为低地址）

大端读数为0x12345678;小端读数为0x78563412

 

4.结构体和数组当作参数传递到函数

结构体会拷贝一个副本给函数，在函数内的修改对原始数据不产生影响；

数据传递的是首地址，函数内的修改对原始数据有影响。

 

5.C宏

定义一年有几秒（忽略瑞年）

#define SECONDS_PER_YEAR (365 * 24 * 60 * 60)UL

二数求小的宏

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

 

6.C中基本类型的定义

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

 

7.关键字static的作用

1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2). 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

4). 在类内，静态函数表示不需要实例就可以调用

 

8. 引用与指针的区别

1) 引用必须被初始化，指针不必。

2) 引用初始化以后不能被改变，指针可以改变所指的对象。

2) 不存在指向空值的引用，但是存在指向空值的指针.

 

9.死循环的写法

1）while(1){}

2) for(;;){}

3)Loop:{}goto Loop;

 

10.C++ String类的实现

#include 

#include <string.h>

using std::ostream;

class String {
    friend ostream& operator<<(ostream& out, const String& str);

    public:
        String(const char* str);        //Constuctor
        String(const String& other);        
        ~String(void);
        String& operator=(const String& other);
        char* data(void) const;
    private:
        ostream& Print(ostream& out) const;
        char* _data;
};

ostream& operator<<(ostream& out, const String& str)
{
    return str.Print(out);
}

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

String::~String(void)
{
    delete[] _data;
}

String& String::operator=(const String& other)
{
    if (this != &other) {
        delete[] _data;
        size_t len = strlen(other.data());
        _data = new char[len + 1];
        // if _data == NULL throw Exception
        strcpy(_data, other.data());
    }
    return *this;
}

char* String::data(void) const
{
    return _data;
}

ostream& String::Print(ostream& out) const
{
    out << _data;
    return out;
}

 11. C++ new

new函数可以重载；

new操作符不可以重载。

 

12. 枚举

枚举只能是整型，值会自动连续

 enum e {
         A = -5,
         B,
         C = 3, 
         D, 
         E = -8, 
         F};
 printf("%d, %d, %d, %d, %d, %d", A, B, C, D, E, F);

// 输出-5 -4 3 4 -8 -7

 13.memcpy, memmove, strcpy 实现

void* memcpy(void* dest, const void* src, size_t n)
{
      char* d = (char*) dest;
      const char* s = (const char*) src;
      
      while (n--)
            *d++ = *s++;
      return dest;
}

void* memmove(void* dest, const void* src, size_t n)
{
      char* d = (char*) dest;
      const char* s = (const char*) src;
      
      if (s > d) {            // start at beginning of s
            while (n--)
                  *d++ = *s++;
      } else if (s < d) {     // start at end of s
             d = d + n - 1;
             s = s + n - 1;
             while (n--)
                   *d-- = *s--;
      }
      return dest;
}

char* strcpy(char* dest, const char* src)
{
      assert(dest);
      assert(src);
      char* d = dest;
      const char* s = src;
      
      while (*str != '\0')
            *d++ = *s++;
      *d = '\0';
      return dest;
}

 

转载于:https://www.cnblogs.com/Leo-Forest/p/3130451.html