TT的博客

描述：override保留字表示当前函数重写了基类的虚函数。目的：1.在函数比较多的情况下可以提示读者某个函数重写了基类虚函数（表示这个虚函数是从基类继承，不是派生类自己定义的）；2.强制编译器检查某个函数是否重写基类虚函数，如果没有则报错。用法：在类的成员函数参数列表后面添加该关键字既可。class Base ｛virtual void f();}；class Derived : public Base {void f() override; // 表示派生类重写基类虚函数fvoid

A *pa = new A();A *pa2 = new A;如果A是空类，那么以上两种写法没有区别，但是写一个空类是无意义的。类A中有成员变量则带括号的初始化会把一些成员变量有关的内存清0，但不是整个对象内部全部清0（无构造函数）。有构造函数时，两种写法是一样的，初始化一般在构造函数里做。除了对类的new，如果是基本类型如下int *pa3 = new int;//初值随机int *pa4 = new int();//初值0int *pa5 = new int(100);//初值100

auto_ptr(c++98)、unique_ptr(C++11)、shared_ptr(c++11)、weak——ptr(c++11),帮助我们进行动态分配对象(new)出来的生命周期管理。能够有效防止内存泄漏。目前auto_pr已经完全被unique_ptr取代。shared_ptr:共享式指针。多个指向同一个对象，最后一个指针被销毁时，这个对象就会被释放。weak_ptr是辅助shared_ptr工作的。unique_ptr：独占式指针。同一时间内，只有一个指针能够指向该对象。make_sha

可变参模板（Variadic Templates）：允许模板中含有0个到任意个模板参数，在语法上也和传统模板不太一样，多了…可变参函数模板，简单的认识#include <iostream>using namespace std;template<typename... T>void myfunct1(T... args){ cout << sizeof...(args) << " " << sizeof...(T) <&l

文章目录一、类模板特化1.1类模板全特化a）常规全特化b）特化成员函数而不是模板1.2类模板的偏特化(局部特化)模板参数数量偏特化模板参数范围特化函数模板特化特化反义就是泛化，泛化：模板，可以随便指定类型特化：对特殊的类型（类模板参数）进行特殊的对待一、类模板特化1.1类模板全特化a）常规全特化必须先有泛化版本才能存在特化版本。只要涉及特化，一定先存在泛化。特化版本代码编译器会优先选择。#include <iostream>#include <map>using

typedef：一般用来定义别名typedef unsigned int uint_t;uint_t abd;//unsigned int再来看看以下代码#include <iostream>#include <map>int main(){ typedef unsigned int uint_t; uint_t abd;//unsigned int typedef std::map<std::string, int> map_s_i; map

一、普通类的成员函数模板不管是普通类还是模板类，它的成员函数可以是一个函数模板，称为“成员函数模板”，不可以是虚函数，否则编译器会报错。#include <iostream>using namespace std;class A{public: template <typename T> void myft(T temp)//成员函数模板 { cout << temp << endl; }};int main(){ A

#include <iostream>using namespace std;typedef int(*FunType)(int, int);int mf(int tmp1, int tmp2){ return tmp1+ tmp2;}template <typename T, typename F>void testfunc(const T &i, const T &j, F funcpoint){ cout << funcp

函数echovalue与biggerthanzero的重载的 () ，调用参数和返回值相同就叫做“调用形式相同”。int(int);//接收一个int，返回一个int#include <iostream>using namespace std;//如果值<0,那么返回0,否则返回实际值class biggerthanzero{public: //重载圆括号(函数运算符) int operator()(int value)const { cout <<

#include <iostream>using namespace std;void func(int i){ cout << "func被调用" << endl;}int main(){ func(3); return 0;}func被调用圆括号()就是函数调用的明显标记，()有一个称呼叫做“函数调用运算符”。如果我们在类中重载了函数调用运算符(),那么我们就可以像使用函数一样使用该类的对象了。对象(实参)使用函数调用运算符#in

把函数指针作为某个函数的参数进行传递#include <iostream>using namespace std;typedef int(*FunType)(int, int);//定义一个函数指针类型int mf(int temp1, int temp2){ return 1;}void testfunc(int i, int j, FunType funcpoint){ int result = funcpoint(i, j); cout << re

typename使用场合1、函数模板template<typename T,int a, int b>//typename后边跟的是一个类型int funcaddv2(T c){ .... };类模板//template<class T>//可以写为class，但这里class不能与定义类的class混淆template<template T>//名字为T的模板参数class myvector { ... };2、使用类的类型成员，用typenam

一、概述用类模板来实例化一个特定的类。编译器不能为类模板推断模板参数类型，所以为了使用类模板，我们必须在模板名后边用<>来提供额外的模板信息。这些信息就是对应模板列表参数里面的参数。二、类模板定义template<typename 形参名1, typename 形参名2, … typename 形参名n>class 类名{};实例化类模板的时候，必须要有类的全部信息，包括类模板中成员函数的函数体。#include <iostream>using nam

一、概述所谓泛型编程是以独立于任何特定类型的方式编写代码。使用泛型编程时，我们需要提供具体程序实例所操作的类习惯或者值模板是泛型编程的基础。模板是创建类或者函数的蓝图或者公式。我们给这些蓝图或者公式提供足够的信息，让这些蓝图或者公式真正的转变具体的类或者函数，这种转变发生在编译时。模板支撑将类型作为参数的程序设计方式，从而实现了对泛型程序设计的支持。也就是说，C++模板机制允许在定义类、函数时将类型作为参数。模板分为函数模板和类模板，这里介绍函数模板。二、函数模板的定义看如下代码int f

文章目录一、RTTI是什么（Run TIme Type Identificantion）二、dynamic_cast运算符三、typeid运算符四、type_info类五、RTTI与虚函数表一、RTTI是什么（Run TIme Type Identificantion）Run TIme Type Identificantion：运行时类型识别；通过运行时类型的识别，程序能够使用基类的指针或者引用来检查这些指针或者引用所指的对象的实际派生类型。如之前博客虚函数写到A是B、C类的基类，A类定义一个指针指

一段代码中B、C类都是继承自父类A，A、B、C类中有同名同参函数mtest，父类指针可以指向子类，但子类空间不能指向父类。#include <iostream>using namespace std;class A{public: A(int a=1) :m_a(a){ } void matest(int n); void mcout() { cout << "acout" << endl; }private: int m_a; };

关键字friend一、友元函数：函数func声明成类A的友元函数，那么func这个函数就能访问类A的所有成员，不受三种权限限制。二、友元类：A类可以把B类（其它类）定义成友元类。如果B是A的友元类那么，那么B就可以在自己的成员函数中访问A类的所有成员，不受三种权限限制。友元关系不能被继承友元关系是单向的如B是A的友元类，但不代表A是B的友元类。友元关系没有传递性，比如类B是类A的友元类，类C是类B的友元，并不代表C是A的友元类。三、友元成员函数（即是成员函数也是友元函数）只有public的

子类中如果有一个同名函数，那么父类中，不管几个同名函数，子类都无法访问到。那么我们想要访问父类的同名函数该怎么办？？？（1）在子类的成员函数中使用 “父类::成员函数”（2）关键字uisng 有一个功能C++11 :让父类同名函数在子类中可见using 父类::成员函数;只能指定函数名，则凡是基类中的public的成员函数(与父类同名)，在子类中都可见，你无法让一部分父类中的同名函数可见。using 引入的主要目的是用来实现在子类对象中调用父类的重载版本。该函数在父类中的参数跟子类中的参数，

== , > , >= , < , <= , != , ++ , – , + , - , cout的<<和 >> =重载运算符，本子上是一个函数。整个函数的名字：operator关键字+运算符，既然重载运算符本质上是一个函数，那么会有返回类型和参数列表。#include <iostream>using namespace std;class A{public: A(int a) :m_a(a){ } void matest(i

首先来看一下如下代码，之前在学习命名空间的时候知道用using namespace std;声明后直接调用cout就不用写前面的std::，那么在matest函数中，给m_a赋值为什么是A::m_a呢#include <iostream>using namespace std;class A{public: A(int a):m_a(a){} void matest(int n); void macout() { cout << m_a << e

mutalbe的中文意思是“可变的，易变的”，跟constant（既C++中的const）是反义词。在C++中，mutable也是为了突破const的限制而设置的。被mutable修饰的变量，将永远处于可变的状态，即使在一个const函数中。我们知道，如果类的成员函数不会改变对象的状态，那么这个成员函数一般会声明成const的。但是，有些时候，我们需要在const的函数里面修改一些跟类状态无关的数据成员，那么这个数据成员就应该被mutalbe来修饰。以下代码如果要在matest中进行修改m_a的值，就

构造函数：在类中，有一种特殊的成员函数，它的名字和类名相同，我们在创建类的对象的时候，这个特殊的成员函数就会被系统自动调用。这个成员函数，就叫构造函数；因为构造函数会被系统自动调用，所以我们可以简单理解成：构造函数的目的就是初始化类对象的数据成员。...

1、隐试类型转换隐试类型转换：系统自动进行，不需要程序开发人员介入#include <iostream>#include <string>#include <vector>#include <string>using namespace std;int main(){ int m = 3 + 45.6;//48, 把小数部分截掉，也属于隐试转换的一种行为 double n = 3 + 45.6; return 0;}2、显示类

一、迭代器简介  迭代器是一种遍历容器内元素的数据类型，这种数据类型有点像指针，理解时候可以理解为迭代器用来指向容器中的某个元素。vector可以用[]来访问，但是更常用的访问方式是用迭代器。通过迭代器，我们可以读容器中的元素值，读string中的每个字符，还可以修改某个迭代器所指向的元素值。一般有容器都会有相关的迭代器list、map等。二、容器的迭代器类型vector <int> iv = {100,200,300};vector<int>::iterator it

vectoc：标准库：集合或者动态数组，可以把若干对象放在里面。vector它能把其他对象装进来，也被称为容器。#include <iostream>#include <string>#include <vector>using namespace std;int main(){ vector <int> vjihe;//表示这个里面保存的是int型数据 return 0;}:类模板，vector之后加一对<>.<

C++11中引入的关键字nullprt也是代表空指针#include <iostream>using namespace std;int main(){ char *p = NULL; char *q = nullptr; //int a = nullptr;//不可以 int b = NULL; if (p == nullptr) { cout << "p == nullptr" << endl; } if (q == NULL) {

遍历一个序列#include <iostream>using namespace std;int main(){ int v[]{12,13,14,15,16}; for(auto x:v) { cout << x <<endl; }}结果1213141516以上代码依次拷贝到x中，并打印x。可以用引用代替拷贝，这样就可以提升系统效率，输出结果是一样的。for(auto &x:v){ cout << x

有3个文件分别是text1.h text2.h text.ctext1.hint a=1;text2.h#include "text1.h"int b = 2;text.c#include "text1.h"#include "text2.h"#include <iotaream>int main(){ return 0;}//报错 会提示a重复定义以上text.c可以翻译为如下int a=1;//#include "text1.h"int a=1;//

auto：变量的自动类型推断auto可以在声明变量的时候根据变量初始值的类型自动为此变量选择匹配类型（声明时要初始化）auto自动类型推断发生在编译期间，所以auto不会造成程序效率降低

如下int i;std::cout<<i--<<i--;//2,3在vs2017中运行的结果是2,3这个是不同编译器运行的结果是不一样的。

在进行c++开发中std::cout末尾常常会跟一个std::endl，以前理解是换行，但是"\n"也是换行，今天发现除了换行的作用还有就是强制刷新缓冲区std::endl作用1、输出换行符"\n"2、强制刷新输出缓冲区，缓冲区所有数据都被系统清除了输出缓冲区：一段内存。cout输出的时候实际是往输出缓冲区输出内容，那么什么时候会刷新缓冲区呢？缓冲区满了程序执行到main的return语句调用std::endl当系统不再繁忙的时候其它...

C++中命名空间可以理解为多个人同时对一个项目进行开发，那么就会遇见这么一个问题，张三有一个叫void fun();的函数，李四也有一个叫void fun();的函数，虽然在不同的源文件，但是会出现重定义的现象。namespace关键字就是为了解决命名问题，命名空间可以不连续，甚至可以写在多个文件中，如果你以往没有定义这个命名空间，那么“namespace”命名空间这种写法就相当于定义了一个命名空间，如果你以往已经定义了这个命名空间，那么“namespace”命名空间名这种写法就相当打开已经存在的命名空间

派生类都只有一个基类，称为单继承。除此之外，C++也支持多继承，即一个派生类可以有两个或多个基类。多继承的语法也很简单，将多个基类用逗号隔开。例如已声明了类A、类B和类C，那么可以这样来声明派生类D：class D: public A, private B, protected C{ //类D新增加的成员}D 是多继承形式的派生类，它以公有的方式继承 A 类，以私有的方式继承 B 类，以保护的方式继承 C 类。D 根据不同的继承方式获取 A、B、C 中的成员，确定它们在派生类中的访问权

C++基类和派生类的构造函数基类的成员函数可以被继承，可以通过派生类的对象访问，但这仅仅指的是普通的成员函数，类的构造函数不能被继承。构造函数不能被继承是有道理的，因为即使继承了，它的名字和派生类的名字也不一样，不能成为派生类的构造函数，当然更不能成为普通的成员函数。在设计派生类时，对继承过来的成员变量的初始化工作也要由派生类的构造函数完成，但是大部分基类都有 private 属性的成员变量，它们在派生类中无法访问，更不能使用派生类的构造函数来初始化。这种矛盾在C++继承中是普遍存在的，解决这个问题的

C++继承时的名字遮蔽问题如果派生类中的成员（包含成员变量和成员函数）和基类中的成员重名，那么派生类中的成员就会遮蔽从基类继承过来的成员。所谓遮蔽，就是在派生类中使用该成员（包括在定义派生类时使用，也包括通过派生类对象访问该成员）时，实际上使用的是派生类新增的成员，而不是从基类继承来的。#include <iostream>using namespace std;//基类Peopleclass People{public: void show();//基类的showp

#include <iostream>using namespace std;/*继承与派生，它们是一个概念，只是角度不同B类继承A类，那么A类的功能B类都有，同时B类可以在A类的基础上扩展更多功能以下People为A类，Student为B类称为A派生B，B继承A叫法不同又称A、B为基类与派生类或父类与子类一般语法为class 派声明:[继承方式] 基类名{ 派生类新添的成员};继承方式：public(公有的)、pravate(私有的)、protected(受保护的)

注释包含许多关键点以及注意事项#include <iostream>using namespace std;/*C++中引用可以看做是一个数据的别名，通过别名和原来的名字都能够找到这份数据引用的定义方式类似于指针，只是用&取代了*type & name = data;注： 引用必须在定义的时候初始化，并且要从一而终，不能引用其它数据，这点有点类似于常量（const变量） 引用在定义时需添加 & ， 使用时候无需加 &, 使用时加&表示

#include <iostream>#include <string>using namespace std;/*string是C++中常用的一个类*/void stringFun(void){ string s1;//创建一个字符串默认为"" string s2 = "hello world";//创建一个字符串但末尾没有/0 string s3 = s2;//与s2内容一样 string s4 (5, 's');//由5个字符组成"sssss" int

简介通过执行 void xxxxFun（）对C++中内容进行学习，本次学习包含this、static、const、friend（友元）、类和结构体的区别。主要看注释。源码#include <iostream>using namespace std;/*this使用this 是 C++ 中的一个关键字，也是一个 const 指针，它指向当前对象，通过它可以访问当前对象的所有成员。this 只能用在类的内部，通过 this 可以访问类的所有成员，包括 private、protec