（1）语言特性：
（2）垃圾回收：
（3）应用场景
（1）编译阶段
（2）安全性
（3）内存占用
//i可以是int型或者const int型
void fun(const int&i){
//...
}
（1）概念区分
（2）example
int a=10;
int* const b1=&a;//顶层const，b1本身是一个常量
const int* b2=&a;//底层const，b2本身可变，所指的对象是常量
const int b3=20;//顶层const，b3是常量不可变
const int* const b4=&a;//前一个const为底层，后一个为顶层，b4不可变
const int& b5=a;//用于声明引用变量，都是底层const
（3）区分作用
int num_c=3;
const int* p_c=&num_c;//p_c为底层const的指针
//int *p_d = p_c; //错误，不能将底层const指针赋值给非底层const指针
const int *p_d = p_c; //正确，可以将底层const指针复制给底层const指针
- 使用命名的强制类型转换函数const_cast时，只能改变运算对象的底层const
int num_e = 4;
const int *p_e = &num_e;
//*p_e = 5; //错误，不能改变底层const指针指向的内容
int *p_t=const_cast<int*>(p_e);//正确，const_cast可以改变运算对象的底层const。但是使用时一定要知道num_e不是const的类型。
*p_f=5;//正确，非顶层const指针可以改变指向的内容
cout<<num_e<<endl;;
class A
{
virtual void foo();
}
class B:public A
{
void foo();//OK
virtual void foo();//OK
void foo() override;//OK
}
class A
{
virtual void foo();
}
class B:public A
{
virtual void f00(); //OK，这个函数是B新增的，不是继承的
virtual void f0o() override;//Error, 加了override之后，这个函数一定是继承自A的，A找不到就报错
}
class Base
{
virtual void foo();
}
class A:public Base
{
void foo() final; foo 被override并且是最后一个override，在其子类中不可以重写
}
class B final:A// 指明B是不可以被继承的
{
void foo() override; // Error: 在A中已经被final了
}
class C:B // Error: B is final
{
}
/*C++中的直接初始化指的是直接调用类的构造函数进行初始化，如下例如*/
string a; //调用默认构造函数
string a("hello"); //调用参数为const char *类型的构造函数
string b(a); //调用拷贝构造函数
/*复制初始化指的是用“=”号来初始化对象，例如*/
string a="hello";//相当于隐式调用构造函数
string b=a;//注意这里相当于隐式调用拷贝构造函数，而不是调用赋值运算符函数
class A{
public:
int num1;
int num2;
public:
//A(int a=0,int b=0){num1=a;num2=b;}
A(int a=0, int b=0):num1(a),num2(b){};//构造参数列表实现
A(const A& a){};
//重载 = 号操作符函数
A& operator=(const A& a){
num1 = a.num1 + 1;
num2 = a.num2 + 1;
return *this;
};
};
int main(){
A a(1,1);
A a1=a;//拷贝初始化操作，调用拷贝构造函数
A b;
b=a;//赋值操作，对象a中，num1 = 1，num2 = 1；对象b中，num1 = 2，num2 = 2
return 0;
#ifndef __MY_HANDLE_H__
#define __MY_HANDLE_H__
extern "C"{
typedef unsigned int result_t;
typedef void* my_handle_t;
my_handle_t create_handle(const char* name);
result_t operte_on_handle(my_handle_t handle);
void close_handle(my_handle_t handle);
}
#endif//__MY_HANDLE_H__
/*========c++调用c函数*/
//xx.h
extern int add(...)
//xx.c
int add(){}
//xx.cpp
extern "C"{#include "xx.h}
/*========c调用c++函数*/
//xxx.h
extern "C"{int add()}
//xxx.cpp
int add(){}
//xxx.c
extern int add();