C++知识汇总

基础部分

输入输出

cin 输入
cout 输出
cout << "Hello" << endl; endl相当于换行

函数重载

C++编译器会将同名函数重重命名，根据输入参数不同调用不同的函数

void test(){}
void test(){int v1}
void test(int v1, int v2){}

test();//调用第一个
test(1);//调用第二个
test(2,3);//调用第三个

函数重载注意点：函数的返回值必须一致

默认参数

void test(int v1, int v2=5){}//v2为默认参数

默认参数的顺序为从右向左

C语言编译 extern “C”

extern "C"{}//大括号内的内容按照C语言方式编译

引入C语言函数使用extern "C"对引用部分进行编译

extern "C" {
		#include "math.h"
	}

C++文件自动添加宏定义

#define __cplusplus

举例：（C/C++混合编程）在math.h头文件中

#ifdef __cplusplus
extern "C" {
#endif //__cplusplus
	int sum(int a,int b);
	int delta(int a, intb);
#ifdef __cplusplus
}
#endif //__cplusplus

该宏定义作用为C和C++都可以使用该头文件，都可以直接使用#include “math.h”

#ifndef #define #endif防止头文件重复包含

#ifdef __(大写文件名) //没有特殊意义，只是为了区分
#define __(大写文件名)
...(头文件内容)
#endif

在C++中可以使用 #pragma once防止重复定义

优点：简单方便； 缺点：不兼容C++低版本编译器；区别：#pragma once针对的是整个头文件

##内联函数 inline
内联函数直接将函数展开为函数体代码，减小函数调用开销，但是会增大函数体积，一般不超过10行，注意：递归函数不会内联

inline int sum(int a, int b){
	cout << "Hello" << endl; 

}

常量修饰符const

const修饰符号右边的内容

 *const p	//p不可修改
 const *p	//*p不可修改

引用 Reference

引用相当于简化版的指针

int &refAge = age; //引用必须第一时间初始化
refAge = 10;	//refAge相当于age 

常引用可以指向不同类型数据，接受const和非const实参，const引用使用范围大

int sum(const int &v1, const int &v2){
	return v1 + v2;
}
int main(){
	sum(10,20);
}

面向对象

struct和class都可以定义类，struct默认public，class默认private

对象内存

对象的函数占对象的内存

this

this是一个指向对象首地址的指针

内存

内存分为代码块 堆 栈 全局变量区，代码块放置程序的机器码，堆区需要主动申请和释放，栈区放置局部变量

//全局变量区
Person g_person;
int main(){
	//栈空间
	Person person;
	
	//堆空间
	Person *p = new Person;
	return 0;
}

//申请和释放内存,一 一对应
int *p = (int *) malloc(sizeof(int));
free (p)

int *p = new int;
delete(p)

char *p = (char *) malloc(4)//指针指向数组的首地址
free(p) //
p[0] p[1] p[2] p[3]	

char *p = new char[4];
delete[] p	//删除数组用delete[]

堆空间初始化

int *p = (int *)malloc(4)
memset(p,1,4);//将指针p开始的四个字节设置为1

Person person;
person.m_id = 12;
person.m_age = 45;
Person.height = 180;
memset(&person,0,sizeof(person)) //将对象初始化为0

构造函数

成员变量初始化执行构造函数，构造函数可以重载，在类中传入参数通过构造函数传参

//例1
class Person{
	int m_age;
	//构造函数 在new对象时执行
	Person(){
		m_age = 12; 
	}
};
//例2 传参
class Person{
	int m_age;
	Person(int age){
		this->m_age = age;
	}
};
int main(){
	Person *person = new Person(23);//将类中传入参数
}
//例3 重载
class Person{
	int m_age;
	Person(int age){
		this->m_age = age;
	}
	Person(int age,int id){
		this->m_age = age;
		cout << "构造函数执行，id=" << id << endl;
	}
};
int main(){
	Person *person = new Person(12,110);//执行类中的第二个参数
	delete person;
	return 0;
}
//注：
Person person();//并不会创建对象 左边Person为函数类型，右边person()为函数声明

如果自定义了构造函数，除了全局区，其他内存空间的成员变量默认都不会初始化，需要手动进行初始化

析构函数

在对象销毁时调用的函数

struct Person{
	//析构函数 不支持重载 对象销毁执行
	~Person(){
		cout << "~Person()" << endl;
	}
};

一般用于销毁在堆中产生的空间

声明和实现分离

声明在C++类中实现

//Person.h 声明类
#pargma once
class Person{
private:
	int m_age;
public:
	void setAge(int age);
	int getAge();
	Person();
	~Person();
};


//Person.cpp 函数前需要加 类名::
#include "Person.h" //本地路劲头文件使用""
void Person::setAge(int age){
	m_age = age;
}
Person::getAge(){
	return m_age;
}
Person::Person()//构造函数{
	m_age=0;
}
Person::~Person()//析构函数{
}

命名空间

命名空间只能在全局范围内定义，作用为防止名称相互冲突。命名空间可嵌套可合并

namespace A {
	int a= 10;
}
namespace B {
	int a=23;
}
cout<< A::a << endl;//输出10
cout << B::a << endl;//输出23

继承

继承分为三种方式 public protected private

//例
class Person{
private:
	int m_age;
public:
	void run(){
	cout << "run()" <<endl;
	}
};
class Student : public Person{
public:
	void study(){
		cout << m_age <<endl;
		cout << "study" << endl;
	}
};

父类如果是私有变量，子类无法访问