C++基础语法总结

构造函数

编译器默认生成一个没有参数的构造函数和一个拷贝构造函数。

默认构造函数

• 如果类内部没有显式写出构造函数，编译器会自动生成一个默认构造函数。

初始化构造函数

• explicit防止隐式调用，默认是implicit.
• 在声明explicit Base(int _data)以后调用a = 1，仍可以进行隐式转换，原因是Base(double _data)，编译器先把int转成double，再调用Base(double _data)。

拷贝构造函数

• 同样地，没有显式写出拷贝构造函数，编译器会自动生成一个。

#include <iostream>

class Base {
public:
  // 默认构造函数
  Base() = default;

  // 初始化构造函数
  // explicit防止隐式调用
  explicit Base(int _data) : data(_data) {}
  Base(double _data) : data1(_data) {}

  // 拷贝构造函数
  Base(const Base &b) : data(b.data), data1(b.data1) {
    std::cout << "调用复制构造函数!" << std::endl;
  }

  void print() const {
    std::cout << data << " " << data1 << std::endl;
  }

  ~Base() {
    std::cout << "调用析构函数!" << std::endl;
  }

private:
  int data{};
  double data1{};
};

int main() {
  Base a(1.0);         // 栈变量
  Base *b = new Base();// 堆指针
  b->print();
  std::cout << "=========" << std::endl;
  a.print();
  a = 2.0;  // 隐式转换，调用Base(double)构造函数
  a.print();// 输出0 2
  a = 1;    // 仍然可以隐式转换，explicit可以避免单参数构造函数隐式调用
  a.print();// 输出0 1
  std::cout << "=========" << std::endl;
  b = new Base(a);// 调用复制构造函数
  b->print();
}

什么情况下会调用拷贝构造函数

• 一个对象以值传递的方式传入函数体。
• 一个对象以值传递的方式从函数返回。
• 一个对象需要通过另外一个对象进行初始化。

那些函数不能是虚函数

• 构造函数
• 内联函数
• 静态函数
• 友元函数
• 普通函数

移动构造函数

在没有右值特性的时候：

#include <iostream>

class Base {
public:
  // 带参构造函数
  Base() : num(new int(0)) {
    std::cout << "construct!" << std::endl;
  }
  // 拷贝构造函数
  Base(const Base &b) : num(new int(*b.num)) {
    std::cout << "copy construct!" << std::endl;
  }
  // 析构函数
  ~Base() {
    std::cout << "class destruct!" << std::endl;
  }

private:
  int *num;
};
Base get_base() {
  return Base();
}

int main() {
  Base b = get_base();
  return 0;
}

输出：

construct!
copy construct!
class destruct!
copy construct!
class destruct!
class destruct!

• 在底层发生两次深拷贝。

  // 移动构造函数
  Base(Base &&b) noexcept : num(b.num) {
    b.num = nullptr;
    std::cout << "move construct!" << std::endl;
  }

• 添加移动构造函数，对b.num进行浅拷贝，再把b.num重置，避免重复析构同一内存区域。
• 简单来说，就是把b.num挪过来用了。这时，访问b.num就会报错。

构造函数析构函数是否可以抛出异常

• C++只会析构已经完成的对象，一个对象的构造函数中发生异常，它的析构函数不会被调用，因此会造成内存泄漏。
• 如果异常从析构函数抛出，而且没有在当地进行捕捉，那么析构函数是执行不全的。

指针参数传递和引用参数传递

指针参数传递

• 本质上是值传递，传递的是一个地址值。
• 在函数中处理的是实参的一个副本，因此修改形参指针，实参指针并不会改变。

引用参数传递

• 传递的是实参变量的地址
• 被调函数的任何操作都被处理成间接寻址，因此被调函数对形参的任何操作都会影响主调函数的实参变量。

const和static

static作用：控制变量的存储方式和可见性

• 修饰局部变量：一般情况下局部变量在程序中存放在栈区，使用static关键字修饰，就存在静态数据区，生命周期一直延续到整个程序执行结束。
• 修饰全局变量：对于一个全局变量，它既可以在本文件中被访问到，也可以在其他源文件中被访问。static修饰全局变量使其变成本文件可见。
• 修饰类：类中某个函数用static修饰，表示函数属于一个类而不是属于此类的任何对象。
• 类成员/类函数声明static：

1. 函数体内static变量得作用范围为该函数体。
2. 在模块内：static全局变量可以被模块内的其他函数访问，static函数可以被模块内的函数调用，作用范围是模块内。
3. static成员变量属于整个类拥有，所有对象只有一份拷贝。
4. static类对象和变量都要在类外初始化。

class Base {
public:
  static int test;
};

int Base::test = 10;

int main() {
  std::cout << Base::test << std::endl;
}

5. static修饰的类成员属于类，因此类成员函数没有this指针，因此不能访问非static的类成员变量。
6. static成员函数不能被virtual修饰。

const关键字：含义及实现机制

• const修饰基本类型数据类型：不能改变基本类型数据值。

  const int a = 100;
  // a = 10; 编译出错

• const修饰指针变量和引用变量：const位于小星星左侧，const用来修饰指针所指向变量，即指针指向为常量，位于右侧则为指针本身是常量。

  const int *a = new int(24);
  // *a = 100; 编译出错 
  int *const a = new int(24);
  *a = 100;
  // a = new int(100); 编译出错，指针本身是常量。

• const应用到函数中：参数是const，局部变量是常量。

int test(const int a) {
  // a = 19; 编译出错，局部变量是常量。
  return a;
}

• const在类中的用法：const成员变量，某个对象生命周期内该变量是常量。const成员变量的初始化只能在构造函数的初始化列表中进行。

class Base {
public:
  const int data{123};
  // Base(int _data) : data(_data){};
};

class Base1 {
public:
  const int data;
  Base(int _data) : data(_data){};
};

• const成员函数：主要目的是防止成员函数修改对象的内容。const和static不能同时修饰成员函数，但可以修饰成员变量，该成员变量在整个类不能被修改。

class Base {
public:
  const static int data{123};
  int data2 = 10;
  //  void change() const {
  //    data2 = 100;
  //  }
};

// int Base::data = 321;

• const修饰对象：常量对象只能调用常量函数，别的成员函数不能调用。const成员函数想修饰某个变量，可以使用mutable进行修饰。

class Base {
public:
  const static int data{123};
  mutable int data2 = 10;
  void change() const {
    data2 = 100;
  }
};

C和C++区别

• 新增的语法和关键字：命名空间，new，delete，引用，auto…
• 重载和虚函数：名字修饰不同。
• 虚函数，多态。
• struct：增加权限访问。class默认权限是private。
• 模板重用，STL。

C++和Java区别

• 指针
• 多重继承
• 数据类型和类
• 自动内存管理
• 类型转换
• 字符串

C++的常量

• 局部变量，存放在栈区。
• 全局变量，编译器不分配内存，放在符号表中。
• 字面量常量，放在常量区。

C++中重载和重写，重定义的区别

重载

同一作用域内被声明的几个具有不同参数列表的同名函数，依赖于C++函数名字。

• 参数类型、个数、顺序的不同。
• 不关心函数的返回类型。

重写

派生类中重新定义弗雷中除了函数体外完全相同的虚函数。

• 除函数体外完全相同的虚函数。
• 访问修饰符可以不同。
• 不可以是static。

重定义（隐藏）

• 派生类重新定义父类中相同名字的非virtual函数，参数列表和返回类型都可以不同。

指针和引用的区别

• 指针的内容是内存地址，引用只是一个别名。
• sizeof引用得到对象的大小，sizeof指针得到指针本身的大小。

野指针和悬空指针

• 野指针：没有被初始化过的指针。
• 悬空指针：最初指向的内存已经被释放了的一种指针。

函数指针

• 函数指针是指向函数的指针变量。
• 用途：调用函数和做函数的参数，比如回调函数。

堆和栈的区别

栈

由编译器进行管理，自动回收空间，一般保存的是局部变量和函数参数。

堆

由程序员管理，需要手动new malloc delete free进行分配和回收。

函数传递参数的几种方式

值传递

形参是实参的拷贝。

指针传递

实质是值传递的一种，形参是实参地址的指针。

引用传递

把引用对象的地址放在了开辟的栈空间中。

new/delete, malloc/free区别

new

1. 分配未初始化的内存空间(malloc)。
2. 使用对象的构造函数对空间进行初始化。
3. 返回空间的首地址。

delete

1. 使用析构函数对对象进行析构。
2. 回收内存空间(free)。

区别

• new和delete都是对一个类型操作，而malloc和free是对字节操作。
• malloc和free是库函数不是运算符。

volatile和extern关键字

volatile三个特性

• 易变性
• 不可优化性
• 顺序性

extern

在C++中，用于指示C或者C++函数的调用规范。

define和const区别

• define,实际上是在预编译阶段进行处理，没有类型，没有类型检查。
• const是编译期间进行处理的，有类型检查，程序执行时系统会为const常量分配内存。

面对对象的三大特性

封装

继承

多态