打工人的面试题集锦

前言： 经常回顾C/C++面试题和笔试题，有助于我们对C/C++基础有一个新的认识和记忆。在实际工作中，大部分人会被业务缠身，基础慢慢的遗忘了，对很多基础知识欲言又止！回顾笔试面试题目，会让我们对基础知识掌握更加牢固，同时笔试题也有助于我们开阔思路，提高编程能力，还有就是开源代码阅读，只有不断的回顾和学习，才能不断的进步。

加油吧！打工人！~

class A
{
    char c;
    int a;
    char d;
};
 
cout << sizeof(A) << endl;
 
class B
{
    char c;
    char d;
    int a;
};
 
cout << sizeof(B) << endl;
sizeof（A）=12，sizeof（B）=8；

class Test1
{
public:
    Test1(int n)
    {
        num=n;
    }//普通构造函数
private:
    int num;
};
class Test2
{
public:
    explicit Test2(int n)
    {
        num=n;
    }//explicit(显式)构造函数
private:
    int num;
};
int main()
{
    Test1 t1=12;//隐式调用其构造函数,成功
    Test2 t2=12;//编译错误,不能隐式调用其构造函数
    Test2 t2(12);//显式调用成功
    return 0;
}

bool 型数据： 
if( flag ) 
{ 
  A; 
} 
else 
{ 
  B； 
} 
int 型数据： 
if( 0 != flag ) 
{ 
  A; 
} 
else { 
  B； 
} 
指针型数： 
if( NULL == flag ) 
{ 
  A; 
} 
else { 
  B； 
} 
float 型数据： 
if ( ( flag >= NORM ) && ( flag <= NORM ) ) 
{ 
  A； 
} 

    两种情况下会出现这种内存泄露：一是在堆里创建了对象占用了内存，但是没有显示地释放对象占用的内存；二是在类的构造函数中动态的分配了内存，但是在析构 函数中没有释放内存或者没有正确的释放内存</br>

  方括号是告诉编译器这个指针指向的是一个对象数组，同时也告诉编译器正确的对象地址值病调用对象的析构函数，如果没有方括号，那么这个指针就被默认为只指向一个对象，对象数组中的其他对象的析构函数就不会被调用，结果造成了内存泄露。</br>

   当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确是释放，因此造成内存泄露</br>

 参考链接：https://blog.csdn.net/hyqwmxsh/article/details/52813307    

 缓冲区溢出（栈溢出）</br>
 程序为了临时存取数据的需要，一般会分配一些内存空间称为缓冲区。如果向缓冲区中写入缓冲区无法容纳的数据，机会造成缓冲区以外的存储单元被改写，称为缓冲区溢出。而栈溢出是缓冲区溢出的一种，原理也是相同的。分为上溢出和下溢出。其中，上溢出是指栈满而又向其增加新的数据，导致数据溢出；下溢出是指空栈而又进行删除操作等，导致空间溢出。</br>

#include<stdio.h> 
void main( void ) 
{ 
  int a[5]={1,2,3,4,5}; 
  int *ptr=(int *)(&a+1); 
 printf("%d,%d",*(a+1),*(ptr-1));   return; 
} 

template <typename T> class A 
{ 
  friend T; private: 
  A() {} 
  ~A() {} 
}; 
 
class B : virtual public A<B> 
{ public: 
  B() {} 
  ~B() {} 
}; 
class C : virtual public B 
{ public: 
  C() {} 
  ~C() {} 
}; 
void main( void ) 
{ 
 B b;  //C c; 
  return; 
} 

    int a=1;
    char *p=(char *)&a;
    if(*p==1) printf("小端\n");
    else      printf("大端\n");

#include <iostream>
#include <string>
 
using namespace std;
 
class A{
 private:
  int data;
 public:
  A(int i){ data = i;}  //自定义的构造函数
  A(A && a);     //拷贝构造函数 
  int getdata(){return data;} 
};
//拷贝构造函数 
A::A(A && a){
 data = a.data;
 cout <<"拷贝构造函数执行完毕"<<endl;
}
//参数是对象，值传递，调用拷贝构造函数
int getdata1(A a){
 return a.getdata();
}
//参数是引用，引用传递，不调用拷贝构造函数 
int getdata2(A &a){
 return a.getdata();
} 
//返回值是对象类型，会调用拷贝构造函数
 A getA1(){
  A a(0);
  return a;
 } 
 //返回值是引用类型，会调用拷贝构造函数，因为函数体内生成的对象是临时的，离开函数就消失
 A& getA2(){
  A a(0);
  return a;
 } 
 
 int main(){
    A a1(1);  
    A b1(a1);             //用a1初始化b1，调用拷贝构造函数  
    A c1=a1;              //用a1初始化c1，调用拷贝构造函数  
  
    int i=getdata1(a1);         //函数形参是类的对象，调用拷贝构造函数  
    int j=getdata2(a1);       //函数形参类型是引用，不调用拷贝构造函数  
  
    A d1=getA1();         //调用拷贝构造函数  
    A e1=getA2();        //调用拷贝构造函数  
  
    return 0;  
}  

typedef    (int*)      pINT;#define    pINT2   int*