面试准备

一、笔试题目难题回顾

1、sizeof和strlen

• sizeof计算的是分配空间的实际字节数（对于字符数组则包括'\0'），而strlen则计算的是空间中字符的个数（不包括'\0'）；
• sizeof是运算符，可以以类型、函数作参数；strlen是函数，只能以char*字符串作为参数，且要想得到正确的结果必须包含结束字符'\'0'
• sizeof在编译的时候就将结果计算出来，所以对于以数组名做参数时计算的是整个数组的大小；而strlen是在运行的时候才欧开始计算结果。
• sizeof不能计算动态分配空间的大小

实际应用：

   对于指向字符数组的指针s，sizeof(s)是字符指针的长度，即4；而strlen(s)则是指整个字符串的大小；

   对于一个字符数组s，sizeof(s)是数组在初始化时分配的长度大小；而strlen(s)则是数组中实际字符个数大小。

   对于结构体变量，sizeof在实际计算所占空间大小时需考虑数据对齐问题

 

2、struct变量和uinion变量实际空间大小以及数据对齐问题

  数据对齐：访问数据的地址需满足一定的条件，即能被这个数据的长度所整除。2字节的数据地址要被2整除，4字节的数据地址要被4整除。数据对齐有益于提高CPU实际读取数据时的效率。

  数据对齐有两种方式：编译器默认对齐的自然对齐和用代码指定的强制对齐

  强制对齐代码：#pragma pack（value）

  结构体成员的数据对齐规则：

  a、结构体中的第一个成员的首地址是结构体变量的首地址

  b、结构体中的每一个成员的首地址相对于结构体首地址的偏移量是该成员数据类型大小的整数倍

  c、结构体的总大小是对齐模数的整数倍，对齐模数等于#pragma pack(n)中的n与结构体中最大数据类型的成员大小的最小值

 eg： https://www.cnblogs.com/wsq-888/p/jie-gou-ti-dui-qi-gui-ze-ji-ju-li.html

 

对于Union类型变量，其长度为联合中元类型（如数组，取其类型的数据长度）最大的变量长度的整数倍，且要大于等于其最大成员所占的存储空间

eg：

Union foo{

char s[10];

int i;

}   //其长度需要大于10且是4的倍数，因此是12

 

3、32位和64位下不同数据类型的大小

数据类型	32位	64位
char	1	1
unsigned char	1	1
short	2	2
unsigned short	2	2
int	4	4
unsigned int	4	4
long	4	8
unsigned long	4	8
long long	8	8
float	4	4
double	8	8
long double	8	8
*(指针)	4	8

4、动态内存分配

    静态开辟内存：在栈中开辟固定大小的内存，指定大小必须为常量（其中，在C语言中const int n=10;n不能作为数组长度定义，但C++中可以）

    动态开辟内存：申请内存大小只在程序运行时才确定，一开始无法指定

    malloc(size_t size)：向堆中申请一片连续的可用的内存空间（连续只是逻辑连续并非物理连续），若申请成功则返回这片内存空间的指针；若失败则返回NULL；返回值类型是void*类型，可在malloc前加强制转化成我们所需的类型。

    free：在堆中申请的内存空间不会像栈中存储的局部变量一样，在函数结束后会自动释放，动态申请的内存需要我们手动释放，如果不释放则造成内存泄漏。

    new：这时一个操作符，new是从自由存储区（free store）中为对象动态分配内存空间，自由存储区不仅可以是堆还可以是静态存储区，分配成功时返回的是对象类型的指针（符合类型安全），且分配时无需指定内存大小。

 

二、面试题目准备

1、字符串的逆置

      a = s[i]; s[i] = s[length-1-i]; s[length-1-i] = a;

2、查找字符串中的最长回文字符串

    方法一：

char* LongestPalindrome(char *s)
{
   int length = strlen(s);
   int maxlen = 1;         //回文串长度
   int start = 0;          //回文串起始地址
   char*p = NULL;
   
   for(int i = 0; i < length;i++)
   {
     for(int j = i+1; j < length;j++)
     {
       int tmp1 = i, tmp2 = j;
       while(tmp1 < tmp2 && s[tmp1] == s[tmp2])//判断是否是回文
       {
          tmp1++;
          tmp2--;
       }

       if(tmp1 >= tmp2 && j-i+1 > maxlen)
       {
          maxlen = j-i+1;
          start = i;
       }
   }
   
   for(int i = 0; i < maxlen;i++)
   {
     p[i] = s[start++];
   }
   
   return p;
   
}

     方法二：动态规划求解

char* longestPalindrome(char *str)
{
   const int n = strlen(str);
   bool dp[n][n];
   memset(dp,0,sizeof(dp));

   int maxlen = 1;
   int start = 0;
   for(int i = 0; i < n; i++)
   {
      for(int j = 0; j < i; j++)
      {
         if(i - j < 2)
           dp[j][i] = (str[i] == str[j]);
         else
           dp[j][i] = (str[i] == str[j] && dp[j+1][i-1]);

         if(dp[j][i] && maxlen < i-j+1)
         {
           maxlen = i-j+1;
           start = j;
         }
      }
   }
}

方法三：https://www.jianshu.com/p/c82cada7e5b0

 

面向对象的概念：操作一个个对象，需要先实例化一个对象，然后再进行操作，易于维护和管理，条理清晰。

 

函数重载和函数重写

重载——函数具有相同的名称，但参数列表不相同（参数的个数或者类型不同），返回值可以相同也可以不同（但是如果函数的名称和参数完全相同，仅仅是返回值类型不同，是无法进行函数重载的）

实例：类的构造函数

重写——子类重新定义父类中有相同名称和参数的虚函数，主要出现在继承关系中

• 重写的函数和被重写的函数必须都为virtual函数，并分别位于基类和派生类中；
• 重写的函数和被重写的函数，函数名和函数参数必须完全一致；
• 重写的函数和被重写的函数，返回值相同，或者返回指针或引用，并且派生类虚函数返回的指针或引用的类型是基类中被替换的虚函数返回的指针或引用的类型或者其子类型(派生类型)。

memcopy和strcpy和memmove

memcpy:内存拷贝，可以拷贝任何数据类型的对象

https://blog.csdn.net/lovemysea/article/details/5275612

strcpy:只能拷贝字符串，遇到'\0'就自动结束拷贝

https://blog.csdn.net/tigerjibo/article/details/6841531

memove:源地址和目标地址由重叠部分时用这个更安全

https://www.runoob.com/cprogramming/c-function-memmove.html

 

进程间的通信方式：

https://www.cnblogs.com/zgq0/p/8780893.html

线程通信方式：

https://www.cnblogs.com/linyufeng/p/9671844.html

TCP/IP协议

https://developer.51cto.com/art/201906/597961.htm