c++知识点全概括脑图思维导图

功能

符号

应用程序入口，操作系统调用程序的接口

常见的五种

#include<iostream.h>

#include<iostream> using namespace std;

c++：

c: scanf printf

char

整型

浮点型

[ ]的三种作用

一维数组

二维数组

struct

union

enum

C++

C: malloc() free()

区别

基本数据类型的指针

数组指针 与 指针数组

二级指针

函数指针

结构体指针

地址+1 是加了一个类型的大小

64bit编译器

32bit编译器

声明的时候有*，表示指针变量

*+地址，表示地址操作符，取内容

数字*数字，表示乘法

引用是已定义的变量的别名（另一个名称）,两者用法完全一样了

同类理解

基本数据类型变量的引用

常量的引用

复合数据类型的引用

指针的引用

做函数参数

引用与返回值

1、引用声明就要初始化，指针不用 int *p = NULL;

2、引用不能指向其他变量了，指针则可以任意指向。p = &a; p = &d;

3、引用不占存储空间，指针占空间

4、引用效率更高，指针式间接操作

5、引用更安全，指针可以偏移

6、指针更灵活，直接操作地址，指针更通用c语言和c++都行

声明变量的时候有&，表示引用

变量前边+&，表示取地址

数&数，表示位与运算

循环控制变量有初始值

循环执行条件

初始值的变化

入口条件循环

退出条件循环

结束本次循环，继续下一次循环

跳出所在循环

变量定义的位置

vc和vs结构内定义循环控制变量的作用域区别

C：标准C语言，函数没参数需要写个void

c++:不用写void

return ；

传值与传址

参数缺省值/默认值

同一作用域内

函数名字相同

参数列表不同

void fun(int a); void fun(int a, int b); void fun(char c); void fun(float f, double d);

系统会根据参数的形式，自动找到要调用的函数

例子

函数调用更灵活了

默认参数和重载结合使用，可能会造成调用不明确

返回值不作为函数重载的条件

参数是浮点型float,double的护卫重载的函数，一定要注意参数传递

fopen

fread(),fwrite(),fgets().....

fclose()

二进制与16进制，十进制与16进制， 十进制与2进制

&，|，~，^

malloc

强制类型转换

自动变量

静态变量

注意修饰的位置

#define

#include

#ifndef AAA #define AAA #endif

#pragma once

class 类名 { }；

CPeople op;

CPeople* op1 = new CPeople;

栈区普通对象

堆区指针对象

类的所有成员（个别特殊static），必须通过对象访问

关键字

友元

作用范围

拓展功能

构造函数

析构函数

常函数

static

拷贝构造/复制构造:copy

内联函数

相对特殊

常规

this

继承的作用

继承的格式

继承对象的声明以及成员调用调用

继承的限定词

成员的继承

多态是一种泛型编程思想

虚函数是实现这个思想的语法基础

CFather* p = new CSon;

但是不能调用子类的函数

virtual void fun() ；

子类的函数 要和这个函数一样

多个子类，换子类就调用子类的

多态针对于指针对象

即父类的一个指针，可以有多种执行状态，即多态

重写

不是内联函数

构造函数不能是虚函数

虚函数覆盖原理

取虚表地址，以及内容

delete哪个类型的指针，就调用谁的析构函数

多态中，如果释放父类指针，只会调用父类的析构函数，所以加了虚析构，就会子类父类都调用了

纯虚函数

抽象类

接口类

多个基类

子类的子类

就是将模块或者函数合并在一起生成可执行代码的处理过程，（函数调用），按照联编所进行的阶段不同，可分为两种不同的联编方法：静态联编和动态联编。

指在编译阶段就将函数实现和函数调用关联起来

例子

是指在程序执行的时候才将函数实现和函数调用关联

举个例子

1、构造函数

2、通过静态成员函数申请对象空间，并返回地址

3、定义一个静态标记，记录对象的个数，并控制

4、析构函数，将标记清空，以达到重复申请对象的目的

private

异常中止

try { show();//函数调用 } catch(参数) { } catch(参数) { } show() { throw(12); }

抛出对象的时候，要用引用或者指针，不然会拷贝备份出来，即拷贝构造函数

(type)value

type(value)

static_cast

const_cast

dynamic_cast

reinterpret_cast

常数+常数

左边是左参数，右边是右参数

默认左边是类的类型

必须是C++有效运算符 C++ primer (第五版)

@不是运算符，不能重载这个

（1）、根据实际情况，左操作数不是对象的，就选择类外重载运算符

（2）、=， [ ], ( ), ->必须是成员

（3）、复合赋值运算符通常是成员

（4）、改变对象状态的运算符， 如递增递减和解引用，通常是成员

（5）、算术，关系，位运算，非成员

+ ,- ,* ,/ ,% ,

>= ,<= ,> ,< ,!= ,==

^ ,& ,I

&&，||

正，负，取地址，内存操作符

cout是一个对象

cin是一个对象

ostream& operator<<(ostream& os, const CStu&st){ return os;}

istream& operator>>(istream& is, CStu& st){return is;}

必须类内，否则报错

+=， -+， *=， /=，%=, <<=, >>= , ^=,&=, |=

返回引用

只能类内

左++

左--

右++

右--

1、没有显示返回类型

2、没有参数

3、必须定义成类的成员函数

4、不应该改变对象的内容，所以是const函数

5、避免过度使用

template <typename T> void fun(T tt) { cout << tt << endl; }

书写

可以有多个参数

作用域

就是将我们的指定的类型，单独处理

template<> void fun<job>(job& j1, job& j2);

要单独写个实现

调用：fun(结构1， 结构2)；

原版函数->具体化->模板

生成指定类型的函数定义

template void fun<job>(job& j1, job& j2);

调用：fun(结构1， 结构2)；

没有函数实现

传递的时候会覆盖掉

有默认值的时候可以不传

但是必须要有<>

除了类之外，热河位置出现CFather 都要加上模板参数列表

继承的时候要写

构造函数传递(父类有参数构造）

创建对象时候要写

编译器根据上下文情况，确定auto变量的真正类型

auto作为函数返回值时，只能用于定义函数，不能用于声明函数

class Test { public: void TestWork(int index) { std::cout << "TestWork 1" << std::endl; } void TestWork(int * index) { std::cout << "TestWork 2" << std::endl; } }; int main() { Test test; test.TestWork(NULL); test.TestWork(nullptr); }

使用nullptr的时候，我们能调用到正确的函数

int main() { int numbers[] = { 1,2,3,4,5 }; std::cout << "numbers:" << std::endl; for (auto number : numbers) { std::cout << number << std::endl; } }

不仅仅局限于数据，STL容器都同样适用

std::array相对于数组，增加了迭代器等函数

std::forward_list为C++新增的线性表，与list区别在于它是单向链表

std::map使用的数据结构为二叉树，而std::unordered_map内部是哈希表的实现方式

std::unordered_set的数据存储结构也是哈希表的方式结构

std::thread为C++11的线程类，使用方法和boost接口一样，非常方便，同时，C++11的std::thread解决了boost::thread中构成参数限制的问题，得益于C++11的可变参数的设计风格

std::atomic为C++11分装的原子数据类型

从功能上看，简单地说，原子数据类型不会发生数据竞争，能直接用在多线程中而不必我们用户对其进行添加互斥资源锁的类型。从实现上，大家可以理解为这些原子类型内部自己加了锁

C++11中的std::condition_variable就像Linux下使用pthread_cond_wait和pthread_cond_signal一样，可以让线程休眠，直到别唤醒，现在在从新执行。线程等待在多线程编程中使用非常频繁，经常需要等待一些异步执行的条件的返回结果

智能指针只是用对象去管理一个资源指针，同时用一个计数器计算当前指针引用对象的个数，当管理指针的对象增加或减少时，计数器也相应加1或减1，当最后一个指针管理对象销毁时，计数器为1，此时在销毁指针管理对象的同时，也把指针管理对象所管理的指针进行delete操作

std::shared_ptr包装了new操作符动态分别的内存，可以自由拷贝复制，基本上是使用最多的一个智能指针类型

include <memory> class Test { public: Test() { std::cout << "Test()" << std::endl; } ~Test() { std::cout << "~Test()" << std::endl; } }; int main() { std::shared_ptr<Test> p1 = std::make_shared<Test>(); std::cout << "1 ref:" << p1.use_count() << std::endl; { std::shared_ptr<Test> p2 = p1; std::cout << "2 ref:" << p1.use_count() << std::endl; } std::cout << "3 ref:" << p1.use_count() << std::endl; return 0; }

为了解决std::shared_ptr在相互引用的情况下出现的问题而存在的

std::bind和std::function也是从boost中移植进来的C++新标准，这两个语法使得封装可执行对象变得简单而易用

在众多的C++11新特性中，lamda表达式不仅仅是一个语法新特性，C++11的lamda表达式在一定程度上还冲击着对传统C++编程的思维和想法

示例