C++面试题及源码

B站视频：
https://www.bilibili.com/video/BV1wd4y1x7g8

目录：

• 1.引用和指针的区别？
• 2.从汇编层去解释一下引用
• 3.C++中的指针参数传递和引用参数传递
• 4.形参与实参的区别？
• 5.static的用法和作用？
• 6.静态变量什么时候初始化
• 7. const?
• 8.const成员函数的理解和应用？
• 9.指针和const的用法
• 10.mutable

第1题 引用和指针的区别

#include <iostream>
using namespace std;

int main()
{
	int x = 10;
	int* i = &x;
	int& j = x;

	cout << i << endl;  //0x7ffee6a2c97c
	cout << j << endl;  //10   j是x的别名
	cout <<  j << endl; //0x7ffee6a2c97c，&取地址符号，取实际对象的地址
	//cout << sizeof(*i) << endl;
	//cout << sizeof(j) << endl;

	return 0;
}

/*
1.引用和指针的区别？
1)指针是一个实体，需要分配内存空间。引用只是变量的别名，不需要分配内存空间。
2)引用在定义的时候必须进行初始化，并且不能够改变。指针在定义的时候不一定要初始化，并且指向的空间可变。（注：不能有引用的值不能为NULL）
3)有多级指针，但是没有多级引用，只能有一级引用。
4)指针和引用的自增运算结果不一样。（指针是指向下一个空间，引用时引用的变量值加1）
5)sizeof 引用得到的是所指向的变量（对象）的大小，而sizeof 指针得到的是指针本身的大小。
6)引用访问一个变量是直接访问，而指针访问一个变量是间接访问。
7)使用指针前最好做类型检查，防止野指针的出现；
8)引用底层是通过指针实现的；
9)作为参数时也不同，传指针的实质是传值，传递的值是指针的地址；传引用的实质是传地址，传递的是变量的地址。
*/

2.从汇编层去解释一下引用

从汇编层去解释一下引用

1.9:          int x = 1;
2.00401048    mov         dword ptr [ebp-4],1
3.10:         int &b = x;
4.0040104F    lea         eax,[ebp-4]
5.00401052    mov         dword ptr [ebp-8],eax

x的地址为ebp-4，b的地址为ebp-8，因为栈内的变量内存是从高往低进行分配的。
所以b的地址比x的低。lea eax,[ebp-4] 这条语句将x的地址ebp-4放入eax寄存器
mov dword ptr [ebp-8],eax 这条语句将eax的值放入b的地址
ebp-8中上面两条汇编的作用即：将x的地址存入变量b中，
这不和将某个变量的地址存入指针变量是一样的吗？
所以从汇编层次来看，的确引用是通过指针来实现的。

3.C++中的指针参数传递和引用参数传递

// 3.C++中的指针参数传递和引用参数传递
#include <iostream>
//指定缺省的命名空间
using namespace std;
int caculate(int *pa);
int calulate(int *pa) {
	*pa = 128;
	pa = nullptr;//未改变实参的地址
	cout << pa << endl;
	return 0;
 
 
}
 
int main() {
	
	int a = 10;
	int result = calulate(&a);
	cout << a << endl;
	cout << &a << endl;
}
/*
1)指针参数传递本质上是值传递，它所传递的是一个地址值。
值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，
会在栈中开辟内存空间以存放由主调函数传递进来的实参值，
从而形成了实参的一个副本（替身）。
值传递的特点是，被调函数对形式参数的任何操作都是作为局部变量进行的，
不会影响主调函数的实参变量的值（形参指针变了，实参指针不会变）。
2)引用参数传递过程中，被调函数的形式参数也作为局部变量在栈中开辟了内存空间，
但是这时存放的是由主调函数放进来的实参变量的地址。
被调函数对形参（本体）的任何操作都被处理成间接寻址，
即通过栈中存放的地址访问主调函数中的实参变量（根据别名找到主调函数中的本体）。
因此，被调函数对形参的任何操作都会影响主调函数中的实参变量。
3)引用传递和指针传递是不同的，虽然他们都是在被调函数栈空间上的一个局部变量，
但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。
而对于指针传递的参数，如果改变被调函数中的指针地址，它将应用不到主调函数的相关变量。
如果想通过指针参数传递来改变主调函数中的相关变量（地址），
那就得使用指向指针的指针或者指针引用。
4)从编译的角度来讲，程序在编译时分别将指针和引用添加到符号表上，
符号表中记录的是变量名及变量所对应地址。
指针变量在符号表上对应的地址值为指针变量的地址值，
而引用在符号表上对应的地址值为引用对象的地址值（与实参名字不同，地址相同）。
符号表生成之后就不会再改，因此指针可以改变其指向的对象（指针变量中的值可以改），
而引用对象则不能修改。
*/
#include <iostream>
//指定缺省的命名空间
using namespace std;
int caculate(int &pa);
int calulate(int &pa) {
	pa = 128;//形参为实参的别名
	cout << &pa << endl;
	return 0;
}
 
int main() {
	
	int a = 10;
	int result = calulate(a);
	cout << a << endl;
	cout << &a << endl;
}

4.形参与实参的区别？

#include <stdio.h>

//计算从m加到n的值
int sum(int m, int n) {
    int i;
    for (i = m+1; i <= n; ++i) {
        m += i;
    }
    return m;
}

int main() {
    int a, b, total;
    printf("Input two numbers: ");
    scanf("%d %d", &a, &b);
    total = sum(a, b);
    printf("a=%d, b=%d\n", a, b);
    printf("total=%d\n", total);

    return 0;
}

/*
4.形参与实参的区别？
1)形参变量只有在被调用时才分配内存单元，在调用结束时， 即刻释放所分配的内存单元。
  因此，形参只有在函数内部有效。 函数调用结束返回主调函数后则不能再使用该形参变量。
2)实参可以是常量、变量、表达式、函数等， 无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值， 
  以便把这些值传送给形参。 因此应预先用赋值，输入等办法使实参获得确定值，会产生一个临时变量。
3)实参和形参在数量上，类型上，顺序上应严格一致， 否则会发生“类型不匹配”的错误。
4)函数调用中发生的数据传送是单向的。 即只能把实参的值传送给形参，而不能把形参的值反向地传送给实参。 
  因此在函数调用过程中，形参的值发生改变，而实参中的值不会变化。
5)当形参和实参不是指针类型时，在该函数运行时，形参和实参是不同的变量，他们在内存中位于不同的位置，
  形参将实参的内容复制一份，在该函数运行结束的时候形参被释放，而实参内容不会改变。
1)值传递：有一个形参向函数所属的栈拷贝数据的过程，如果值传递的对象是类对象 或是大的结构体对象，
  将耗费一定的时间和空间。（传值）
2)指针传递：同样有一个形参向函数所属的栈拷贝数据的过程，但拷贝的数据是一个固定为4字节的地址。（传值，传递的是地址值）
3)引用传递：同样有上述的数据拷贝过程，但其是针对地址的，相当于为该数据所在的地址起了一个别名。（传地址）
4)效率上讲，指针传递和引用传递比值传递效率高。一般主张使用引用传递，代码逻辑上更加紧凑、清晰。
*/

5.static的用法和作用？

/*
5.static的用法和作用？

1.先来介绍它的第一条也是最重要的一条：隐藏。（static函数，static变量均可）
 当同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。
2.static的第二个作用是保持变量内容的持久。
 （static变量中的记忆功能和全局生存期）存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。
  共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，
  static可以控制变量的可见范围，说到底static还是用来隐藏的。
3.static的第三个作用是默认初始化为0（static变量）
  其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，
  内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。
4.static的第四个作用：C++中的类成员声明static
1)函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
2)在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
3)在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
4)在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
5)在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。
类内：
6)static类对象必须要在类外进行初始化，static修饰的变量先于对象存在，所以static修饰的变量要在类外初始化；
7)由于static修饰的类成员属于类，不属于对象，因此static类成员函数是没有this指针的，this指针是指向本对象的指针。
  正因为没有this指针，所以static类成员函数不能访问非static的类成员，只能访问 static修饰的类成员；
8)static成员函数不能被virtual修饰，static成员不属于任何对象或实例，所以加上virtual没有任何实际意义；
  静态成员函数没有this指针，虚函数的实现是为每一个对象分配一个vptr指针，而vptr是通过this指针调用的，所以不能为virtual；
  虚函数的调用关系，this->vptr->ctable->virtual function
*/
//Example 1
#include <iostream.h>
void fn();
static int n; //定义静态全局变量
void main()
{
 　　n=20;
 　　cout<<n<<endl;
 　　fn();
}

void fn()
{
　　 n++;
 　　cout<<n<<endl;
}

//Example 3
#include <iostream.h>
void fn();
void main()
{
 　　fn();
 　　fn();
 　　fn();
}
void fn()
{
 　　static n=10;
 　　cout<<n<<endl;
　　 n++;
}

//Example 4
#include <iostream.h>
static void fn();//声明静态函数
void main()
{
 　　fn();
}
void fn()//定义静态函数
{
 　　int n=10;
 　　cout<<n<<endl;
}

//Example 5
#include <iostream.h>
class Myclass
{
public:
 　　Myclass(int a,int b,int c);
 　　void GetSum();
private:
 　　int a,b,c;
 　　static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)
{
 　　this->a=a;
 　　this->b=b;
 　　this->c=c;
 　　Sum+=a+b+c;
}

void Myclass::GetSum()
{
 　　cout<<"Sum="<<Sum<<endl;
}

void main()
{
 　　Myclass M(1,2,3);
 　　M.GetSum();
　　 Myclass N(4,5,6);
 　　N.GetSum();
 　　M.GetSum();

}

//Example 6
#include <iostream.h>
class Myclass
{
public:
 　　Myclass(int a,int b,int c);
 　　static void GetSum();/声明静态成员函数
private:
 　　int a,b,c;
　　 static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)
{
 　　this->a=a;
 　　this->b=b;
 　　this->c=c;
 　　Sum+=a+b+c; //非静态成员函数可以访问静态数据成员
}

void Myclass::GetSum() //静态成员函数的实现
{
　　// cout<<a<<endl; //错误代码，a是非静态数据成员
 　　cout<<"Sum="<<Sum<<endl;
}

void main()
{
 　　Myclass M(1,2,3);
 　　M.GetSum();
 　　Myclass N(4,5,6);
 　　N.GetSum();
 　　Myclass::GetSum();
}

6.静态变量什么时候初始化

/*
6.静态变量什么时候初始化

1)初始化只有一次，但是可以多次赋值，在主程序之前，编译器已经为其分配好了内存。
2)静态局部变量和全局变量一样，数据都存放在全局区域，所以在主程序之前，编译器已经为其分配好了内存，
  但在C和C++中静态局部变量的初始化节点又有点不太一样。
  在C中，初始化发生在代码执行之前，编译阶段分配好内存之后，就会进行初始化，
  所以我们看到在C语言中无法使用变量对静态局部变量进行初始化，在程序运行结束，变量所处的全局内存会被全部回收。
3)而在C++中，初始化时在执行相关代码时才会进行初始化，主要是由于C++引入对象后，要进行初始化必须执行相应构造函数和析构函数，
  在构造函数或析构函数中经常会需要进行某些程序中需要进行的特定操作，并非简单地分配内存。
  所以C++标准定为全局或静态对象是有首次用到时才会进行构造，并通过atexit()来管理。在程序结束，按照构造顺序反方向进行逐个析构。
  所以在C++中是可以使用变量对静态局部变量进行初始化的。
*/

//CHaveStaticDataMemember.h
//

#pragma once

extern int s_iFirst;		//请注意这两个变量的“声明”顺序（定义是在cpp文件中）
extern int s_iSeond;

class CHaveStaticDataMemember
{
public:
	CHaveStaticDataMemember() {};
	~CHaveStaticDataMemember() {};

private:
	static int m_iStaticInitial;
	static int m_iDynInitial;
};


//CHaveStaticDataMemember.cpp
//

//请注意，这个程序在调试的时候，如果类的成员变量采用静态初始化，根本无法进入类的静态成员变量初始化的那个断点，这是因为
//若采用静态初始化方式，类的静态成员是在程序加载时完成的初始化。

//静态初始化：是指用常量对变量进行初始化。其中未赋初值及初值为0的放在bss段，其他放在data段。静态初始化在程序加载时完成。
//动态初始化：是指需要经过函数调用才能完成的初始化，比如说：int a=foo()，或者复杂类型的初始化（需要调用构造函数）等。
//			  对于全局或者类的静态成员变量，是在main()函数执行前由运行时调用相应的代码进行初始化的。而对于局部静态变量，
//			  是在函数执行至此初始化语句时才开始执行的初始化。

#include "CHaveStaticDataMemeber.h"
#include <iostream>

int DuplicateInt(int m)
{
	return 2 * m;
}

//情况1：若类的静态成员变量采用静态初始化，是在加载时完成的，调试时无法跟踪到
//在main()函数执行前由运行时调用相应的代码进行初始化的
int CHaveStaticDataMemember::m_iStaticInitial = 3;				

//情况2：若类的静态成员变量采用动态初始化，是由运行时调用的，调试时可以跟踪到
//在main()函数执行前由运行时调用相应的代码进行初始化的
int CHaveStaticDataMemember::m_iDynInitial = DuplicateInt(3);	

/*	特殊情况：如果说没有头文件中的变量声明，此处是无法编译通过的。
	对于出现在同一个编译单元内的全局变量来说，它们初始化的顺序与他们声明的顺序是一致的（销毁的顺序则反过来），
	而对于不同编译单元间的全局变量，c++ 标准并没有明确规定它们之间的初始化（销毁）顺序应该怎样
*/
int s_iSeond = 5 * s_iFirst;	//由于在头文件中提前声明了s_iFirst和s_iSeond，所以编译时就按照这个顺序进行初始化
int s_iFirst = 5;

//情况3：全局变量和类的静态成员变量一样，如果采用静态初始化，是在加载的时候完成的初始化，调试时无法跟踪到
//在main()函数执行前由运行时调用相应的代码进行初始化的
int s_iGlobalStatic = 8*2;

//情况4：全局变量和类的静态成员变量一样，如果采用动态初始化，是由运行时调用的，调试时可以跟踪到
//在main()函数执行前由运行时调用相应的代码进行初始化的
int s_iGlobalDyn = DuplicateInt(8);

void GetSome()
{
	//情况5：局部静态变量和静态成员变量一样，如果采用静态初始化，是在加载的时候完成的初始化，调试时无法跟踪到
	//在main()函数执行前由运行时调用相应的代码进行初始化的
	static int s_GlobalInfun = 7;
	std::cout << "now in GetSome fun" << s_GlobalInfun << std::endl;
}

int main()
{
	//情况5：局部静态变量和静态成员变量一样，如果采用静态初始化，是在加载的时候完成的初始化，调试时无法跟踪到
	//在main()函数执行前由运行时调用相应的代码进行初始化的
	static int iLocalStatic = 3;

	//情况6：局部静态变量采用动态初始化，是函数执行至此语句完成初始化的，调试时可以跟踪到
	static int iLocalDyn = DuplicateInt(3);

	std::cout << "now in main fun" << std::endl;
	std::cout << iLocalStatic << std::endl;

	GetSome();
	return 0;
}

7.const?

/*
7. const?
1)阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
2)对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
3)在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
4)对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量，类的常对象只能访问类的常成员函数；
5)对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。
6)const成员函数可以访问非const对象的非const数据成员、const数据成员，也可以访问const对象内的所有数据成员；
7)非const成员函数可以访问非const对象的非const数据成员、const数据成员，但不可以访问const对象的任意数据成员；
8)一个没有明确声明为const的成员函数被看作是将要修改对象中数据成员的函数，而且编译器不允许它为一个const对象所调用。
  因此const对象只能调用const成员函数。
9)const类型变量可以通过类型转换符const_cast将const类型转换为非const类型；
10)const类型变量必须定义的时候进行初始化，因此也导致如果类的成员变量有const类型的变量，
  那么该变量必须在类的初始化列表中进行初始化；
11)对于函数值传递的情况，因为参数传递是通过复制实参创建一个临时变量传递进函数的，函数内只能改变临时变量，但无法改变实参。
  则这个时候无论加不加const对实参不会产生任何影响。但是在引用或指针传递函数调用中，因为传进去的是一个引用或指针，
  这样函数内部可以改变引用或指针所指向的变量，这时const 才是实实在在地保护了实参所指向的变量。
  因为在编译阶段编译器对调用函数的选择是根据实参进行的，所以，只有引用传递和指针传递可以用是否加const来重载。
  一个拥有顶层const的形参无法和另一个没有顶层const的形参区分开来。
*/

class Student{
public:
    Student(char *name, int age, float score);
public:
    void show();
    //三个常函数
    char *getname() const;
    int getage() const;
    float getscore() const;
private://三个常变量
    char *m_name;
    int m_age;
    float m_score;
};
//常变量的赋值方式：参数列表
Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }

//常函数的作用就是获取常变量的值，但是又不能修改它们的值，这种措施主要还是为了保护数据而设置的
char * Student::getname() const{
    return m_name;
}
int Student::getage() const{
    return m_age;
}
float Student::getscore() const{
    return m_score;
}

//stu、pstu 分别是常对象以及常对象指针，它们都只能调用 const 成员函数。
int main(){
    const Student stu("小明", 15, 90.6);
    //stu.show();  //error
    cout<<stu.getname()<<"的年龄是"<<stu.getage()<<"，成绩是"<<stu.getscore()<<endl;
    const Student *pstu = new Student("李磊", 16, 80.5);
    //pstu -> show();  //error
    cout<<pstu->getname()<<"的年龄是"<<pstu->getage()<<"，成绩是"<<pstu->getscore()<<endl;
    return 0;
}

8.const成员函数的理解和应用？

/*
8.const成员函数的理解和应用？
①const Stock & Stock::topval (②const Stock & s) ③const
①处const：确保返回的Stock对象在以后的使用中不能被修改
②处const：确保此方法不修改传递的参数 S
③处const：保证此方法不修改调用它的对象，const对象只能调用const成员函数,不能调用非const函数
*/

#include<iostream>

using namespace std;

class point
{
public:
    point(double x_val=0,double y_val=0);
    void print()const {
        //x = 5;这里会报错：试图修改数据成员x
        cout << "x:" << x << ",y:" << y;
    }
    ~point();

private:
    double x;
    double y;
};

point::point(double x_val,double y_val):x(x_val),y(y_val) //参数不需要在使得x_val=0,y_val=0,否则会报错
{
}

point::~point()
{
}
int main() {
    point p(20, 8);
    p.print();
    return 0;
}

9.指针和const的用法

/*
9.指针和const的用法
1)当const修饰指针时，由于const的位置不同，它的修饰对象会有所不同。
2)int const p2中const修饰p2的值,所以理解为p2的值不可以改变，即p2只能指向固定的一个变量地址，但可以通过p2读写这个变量的值。
  顶层指针表示指针本身是一个常量
3)int const p1或者const int p1两种情况中const修饰p1，所以理解为p1的值不可以改变，即不可以给*p1赋值改变p1指向变量的值，
  但可以通过给p赋值不同的地址改变这个指针指向。底层指针表示指针所指向的变量是一个常量。
4)int const *const p;
*/

person p1("abc",200);
const person* p =&p1; //对象是const
person *const p =&p1；//指针是const 
// const 在*之前是对象是const。  const 在*之后是指针是const。

int i=0;
int *const p1=&i;      //不能改变p1的值，顶层const
const int ci=42;       //不能改变ci的值，顶层const
const int *p2=&ci;     //允许改变p2的值，底层const
const int *const p3=p2;//靠右的const是顶层const，靠左的是底层const
const int &r=ci;       //用于声明引用的const都是底层const

10.mutable

/*
10.mutable
1)如果需要在const成员方法中修改一个成员变量的值，那么需要将这个成员变量修饰为mutable。
  即用mutable修饰的成员变量不受const成员方法的限制;
2)可以认为mutable的变量是类的辅助状态，但是只是起到类的一些方面表述的功能，修改他的内容我们可以认为对象的状态本身并没有改变的。
  实际上由于const_cast的存在，这个概念很多时候用处不是很到了。
*/

#include <iostream>

using namespace std;

class A
{
public:
	A(int a):m_a(a){}
	void matest()const;
	void macout()const
	{
		cout << m_a << endl;
	}
private:
	int m_a;
};

void A::matest() const
{
	//m_a = 10;//被const修饰的函数不允许修好任何类状态值(类里面的数据)
	cout << m_a << endl;
}

int main()
{
	const A a(1);
	a.macout();//用const修饰的一个类使用一个const修饰的方法
	return 0;
}


#include <iostream>

using namespace std;

class A
{
public:
	A(int a):m_a(a){}
	void matest()const;
	void macout()const
	{
		cout << m_a << endl;
	}
private:
	mutable int m_a;
};

void A::matest() const
{
	m_a = 10;//在定义时用mutable来突破这层限制
	cout << m_a << endl;
}

int main()
{
	const A a(1);
	a.macout();//用const修饰的一个类使用一个const修饰的方法
	return 0;
}