liuguangsh的博客

关于多态的事例：/* 多态的效果 由于程序运行不可能预测到用户输入哪个数字，因此不可能预先知道要调用哪个对象的函数，指针p是在我们输入一个数时才指向某个对象的。这就叫做动态联编或者运行时联编，相返假如在运行之前就确定好了哪个指针指向哪个对易县，而且在运行时不能更改的叫静态联编或者编译时联编。静态联编由于对象不用对自身进行跟踪，由此速度浪费比较小，而动态联编虽然可以动态追踪对象，灵活

#includeusing namespace std;class MyClass{public: int add(int a, int b) { cout << "call add" << endl; return a + b; }};void main(){ MyClass my1; MyClass *pmy = new MyClass; my1.ad

#includeusing namespace std;class MyClass{public: int add(int a, int b) { return a + b; } int sub(int a, int b) { return a - b; } int divv(int a, int b) { return a / b; }};// 类

#includeusing namespace std;//公有： 可以被该类中的函数、子类的函数、其友元函数访问,也可以由该类的对象访问//注：友元函数包括两种：设为友元的全局函数，设为友元类中的成员函数//私有：private 只能由该类中的函数、其友元函数访问,不能被任何其他访问，该类的对象也不能访问. //保护：protected 可以被该类中的函数、子类的函数、以及其

#include#include#includeusing namespace std;//void operator ()() 对象名当作函数名，重载 ()// () 仅仅适用于当前结构体对象//不适合作为比线程参数，销毁太快struct myStruct{ myStruct() { cout << "create object" << endl; } ~myS

拷贝构造函数使用的时机有：1：类的赋值2：类做为函数的形参而不使用引用时3：类做为函数的返回值#includeusing namespace std;class MyClass06A{ //有默认的拷贝构造函数public: void show() { cout << "x:" << x << " y:" << y << endl; }private:

/*默认拷贝构造，对于数据只是值传递，对于指针 ，则指向同一片内存地址类的内部有指针并分配内存的，需要深拷贝，否则浅拷由。深拷贝需要自己手动*/#define _CRT_SECURE_NO_WARNINGS#include#includeusing namespace std;//数据的拷贝是浅拷贝class MyClass{public: int a; int b;

/*const 不可以用于构造与析构创建对象的时候加const，是常量对象，无法修改数据，只能引用尾部有 const 的方法类的成员如果是const 初始化有二种方式。一：默认初始化，第二构造初始化，但不可以在构造函数内部初始化类中的const 变量成员，无法直接修改，可以间接修改类成员函数，返回值是const饰的，返回是常量。参数是const修饰的，参数只可读不可写。尾部是cons

/* 死锁：二个线程同时锁住一个变量时。 锁住一个变量之后，尽快操作完成解锁，解锁之前不要再锁住其它变量，否则会互锁（死锁）。*//* 注意死锁是因为二个函数的加锁与解锁的顺序有关...如下面的代码： 函数add1: g_mutex1.lock(); (*a)++; g_mutex2.lock(); (*b)++; g_mutex1.unlock(); g_mut

/*编写一个程序，开启3个线程，这3个线程的ID分别为A B C每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示，如：ABCABC...依次递推。*/#include#include#include#include#includeusing namespace std;int LOOP = 10;int flag = 0;mutex m;con

/* 静态成员函数，只能调用静态函数，及静态变量。 静态变量只会初始化一次，变量类中声明 必须初始化 且在类外。如：int MyStu::data = 10; static int data; //类的静态成员不能设置初始值，但可在外部赋值，如：int MyStu::data = 10;*/#includeusing namespace std;class MyStu{pub

/*explicit:只用于构造函数没有explicit下面四种语义都可以：MySoc ms1 = 66; //默认数据转MySoc ms2(99);MySoc ms3 = MySoc(5); MySoc ms4 = (MySoc)5; 上面可以解释为 数据转换、构造、赋值 造成了代码的歧义。有explicit 限定了自动转换。没有 explicit ，代码歧义多，可以解释为构

R"()"; 可以处理比如路径中的转义字符，不需要写二个 \\ ，这时只需要使用 R"(c:\path.txt)"  这样即可，详细见下面代码：#include#includeusing namespace std;void main(){ //R"()"; string str = R"(1234\n\tabc)"; cout << str << endl; strin

lambda 表达式知识：[capture](parameters) mutable ->return-type{statement}1.[capture]：捕捉列表。捕捉列表总是出现在Lambda函数的开始处。实际上，[]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数。捕捉列表能够捕捉上下文中的变量以供Lambda函数使用; 捕捉列表 中放 & 时为引用外

/* 参数都用引用，不会调用拷贝构造。 返回引用不会调用拷贝构造。 同时，拷贝构造深拷贝，赋值重载深拷贝。 注意对象在栈上，有生命周期，拷贝栈上的对象，需要深拷贝。*/#define _CRT_SECURE_NO_WARNINGS#includeusing namespace std;class MyString{public: char *p; int size;

/* 获取虚函数表指针。*/#includeusing namespace std;class Stu{public: virtual void go1() { cout << "走来..." << endl; } virtual void go2() { cout << "跑来..." << endl; } virtual void go3() {

virtual在修饰函数，与修饰继承关系时对类的大小是有区别的，请看下面的代码：virtual 有虚函数表指针，占4个字节。#includeusing namespace std;class Base{};class Base1 :public Base{};class Base2:virtual public Base{};class Base3 :

虚函数调用的几种方式，及虚函数的重载、跨类重载问题。/*虚函数的三种调用方式1：指针2: 引用3：对象（不能实现多态）*/#includeusing namespace std;//继承，默认情况下class是私有继承 struct默认是公有继承//虚函数可以调用成员函数//多态调用依赖于指针 或 引用调用//对象的调用有副本机制，会调用拷贝构造，拷贝一个父类，无法实现

/* 管理类的内存，要通重载 类，函数是共享的，数据是每个对象私有的*/#include#include#includeusing namespace std;class myclass; //类的声明struct info{ myclass *p; //指针，内存首地址（对象的地址） int n; //代表多少个对象。};list myclasslist; /

/*引用包装器 一般使用在模块中，因为模板一般是不会使用引用的，所以这时可以使用引 引用包装器进行引用。*/#includeusing namespace std;templatevoid show(T t){ t += 9;}void main(){ int data = 10; int &rdata(data); show(rdata); cout <

/* 注意 if 前面有二个 _ __if_exists:判断一个标识符存在不存，标识符：变量、函数、类*/#includeusing namespace std;void run(int x){}void main(){ //int num; //__if_exists(num) //注意 if 前面有二个 _ __if_exists(run) { c

#includeusing namespace std;/*一个函数被说明为虚函数，在派生类中覆盖了函数，那么该函数也是个虚函数，不过也可以把它说明为虚函数，这样看起来更直观易懂一些。*/ class A{public: virtual void print()const{cout<<"这是基类的虚函数。\n";} } ; class B:public A { vi

什么叫联编：  将一个调用函数者联结上正确的被调用函数，这一过程叫做函数联编，一般简称为联编。C++的联编共分两种，就是静态联编和动态联编。因此在未加 virtual 说明时，该函数是静态联编即被调函数和调用函数者的关系以及它们的内存地址在编译时都已经确立好了，运行时不再发生变化。这样的好处是速度快，因为运行的时候不用对各个对象的函数进行追踪，只需要传递参数，执行确定好的函数

如果一个类的函数被定义为虚函数，那么这个类的析构函数也应该要定义虚函数，否则在删除对象时会出现子类对象没有被删除的现象，出现内存泄露。如下代码所示：#includeusing namespace std;class A{public: virtual void print(){cout<<"a"<<endl;} A(){cout<<"基类A的构造函数被执行\n"; } /

#includeusing namespace std; struct book { int num; float price; struct book *next; } int main() { // C语言方法 /* malloc()开辟是没有类型的地址 */ void *p = malloc(sizeof(book)); /* 删除 */

关于静态成员变量的二种访问权限的使用区别，一种是公有，一种是私有，访问的区别，见代码：/*我们需要了解的是，假如我们要在一个类中的所有对象间共享某种数据，不如将该数据声明为静态成员变量。假如你不想让该类外的所有函数都可以访问该数据，那么不妨将某定义为私有成员，那么就只有该类的公有成员方法才可以访问它。当然访问的前提是必须创建一个属于该类的对象。 */ #include

/* 空格的 ASCII 为 32 而空字符的 ASCII 为 0 *//* 求的是可见字符的长度 11个 字符串结束标志不可见，所以不计算在内 *//* sizeof:求出所有的字符，包括不可见字符 */#include<iostream>using namespace std;int main(){ char man[20]; /* cin 遇到空格字符就停止输入

C++函数中使用堆内存的删除，并注意删除数组指针的区别：/* 函数如何返回字符串 */#define _CRT_SECURE_NO_WARNINGS#includeusing namespace std;char * get(char *);int main(){ char c[10]; char *ch; cout << "请输入你的名字："; cin >> c;

//join:开启此线程的程序要等被开启的线程结束后才能执行。//调用线程要等被调用线程执行完成后再退出//join总结：让当前主线程等待所有子线程执行完成才退出。//deatch:脱离主线程的绑定，主线程挂了，自动退出，不会报错。// deatch后线程之间不能通信。//joinable:判断是否可以加入。#include#include#include#includeusi

C++中解决线程冲突的二种方式：一：互斥锁 mutex  要引用 mutex 头文件二：元子变量 atomic 在头文件 atomic 代码如下：/*全局：变量，冲突，结果不正确，速度快。mutex:结果正确，速度慢。atomic:结果正确，速度比mutex快。*/#include#include#include //线程互斥量，解决线程安全#include //原

本代码主要是使用LAMBDA表达式与线程的一起使用，还有线程的几个方法的测试：如：获取线程的ID、线程等待，线程等待的几种方法如下：this_thread::sleep_for(chrono::seconds(3));//线程等待 3 秒this_thread::yield();//让CPU先执行其他线程，空闲时再执行些线程this_thread::sleep_until(

/*decltype的使用：以下来自百度百科的解释：在C++中，decltype作为操作符，用于查询表达式的数据类型。decltype在C++11标准制定时引入，主要是为泛型编程而设计，以解决泛型编程中，由于有些类型由模板参数决定，而难以（甚至不可能）表示之的问题。泛型编程在整个1990年代越发流行，对实现类型推导机制的需求也应运而生。为此，许多编译器厂商都基于程序语言现有的功能，自行实现

/*nullptr:不是指针类型，是自定义类型，表示空指针。实际上可以说没有区别。按 C++ 标准来说，template 用于基础数据类型，typename 指类型名，T 可以取 char int double 等。template 用于类，T 可以取任何类。但是这里有一个问题，结构体应该用 typename 还是 class? 结构体肯定不是基础数据类型，但也不是类。所以实际情况

#include#includeusing namespace std;//char str[1024] = { 0 }; //内存静态区//静态区，栈区，堆区 //int *p2 = new (str)int[10]{1,2,3,4,5,6,7,8,9,10}; 分配内存，以str地址为开始//堆区，可以覆盖重写 可以删除//栈区，静态区，可以覆盖重写，不可以删除void

#include#include //函数绑定器using namespace std;using namespace std::placeholders; templatevoid show(T t){ cout << t << endl;}struct MyStruct{ template void show(T t) { cout << t << endl;

函数绑定器不能绑定重载函数，无法识别。 仿函数又叫函数绑定器 主要是把一个类的成员函数当成一个普通函数使用。/* 仿函数又叫函数绑定器 主要是把一个类的成员函数当成一个普通函数使用。 注：绑定时无法进行函数重载。*/#include#includeusing namespace std;using namespace std::placeholders; //占位

/*VS2013: 注意时应该把 把debug 模式换成 releasr 模式下运行，否则会冲突，因为都对内存进行管理。 C++ C语言层 管理内存的区别 C语言层管理内存，管理malloc free 全局 new 局部 new ，都会调用一次构造函数 管理内存即调用局部，又调用全局管理 局部的内内存管理是管理对象的，全局的内存管理是管理基本数据类型 int double...

#include#includeusing namespace std;//链表的每个元素都是一个listvoid main4d(){ listmylist1{ 5, 3, 2, 9 }; listmylist2{ 1, 23, 5, 2 }; listmylist3{ 11, 123, 15, 12 }; list>mylist{ mylist1, mylist2, myl

/*带虚函数与不带虚函数转换的区别。dynamic_cast：必须要有虚函数才可以转换。dynamic_cast:只能处理转换指针或引用，不能转换对象。dynamic_case 只能识别多态数据类型，转换失败就是null多态，父类指针可以根据多态转化为子类指针子类指针存储一个父类指针，转换失败。指针为 00000子类指针转换成父类，自动转换。typeid:自动识别类型，依赖于虚