// CPPTEST.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<iostream>
#include <map>
#include<fstream>
#include<cassert>
#include <sstream>
#include"TMyNumOperator.h"
#include"abc.h"
#include <list>
#include<thread>
#include <vector>
#include <algorithm>
#include <cmath>
#include <chrono>
#include <mutex>
using namespace std;
using std::cin;
using std::cout;
//using namespace std;
//
//class CBase{
//protected://注意，可以使用C#风格的定义时初始化
// std::string name = "NoOne";
// int age = -20;
// int sex = 1;
//public:
// float *pData = new float[20]{1, 2, 3, 4, 5};
//public:
// virtual ~CBase(){//虚析构函数，防止内存泄漏：对基类指针调用delete时，会从子类一直析构到基类
// cout << "~cbase" << endl;
// }
//};
//
////基类的私有成员不会被继承，这和C#完全一样
//class CStudent : public CBase{
//public:
// std::map<int, std::string> _projs;
// CStudent(){
// pData = new float[20]{1, 2, 3, 4, 5};
// }
//public:
// void SetName(const std::string& name){
// CBase::name = name;//如果CBase.name定义为私有，这里就不可访问
// this->name = name; //等价于上一行
// }
//
// const string& GetName(){
// return this->name;
// }
//
// ~CStudent(){//若采用浅拷贝，析构函数被调用多次，pData被删除多次，程序崩溃
// //规避方式：判断pData是否为空，非空才delete[] pData
// //但在不知情的情况下使用pData仍然会出问题，因此浅拷贝导致的问题不可规避
// cout << "~cstudent" << endl;
// delete[] pData;
// pData = NULL;
// }
//};
//
//void TestSTL(){
//
// auto mp = new std::map<int, std::string>();//c++11新风格 auto
//
// mp->insert({ 10, ("h你好") });//c++11新风格，不用再使用std::pair()或std::make_pair()
// mp->insert({ 20, "el" });
// for (auto var : *mp)//c++11新风格for
// {
// std::cout << var.first << "," << var.second << "," << std::endl;
// }
//}
//
//void TestClass(){
// CBase* pbase = new CStudent();
// auto pst = (CStudent*)pbase;
// pst->SetName("xxxx");
// auto name = pst->GetName();
// delete pbase;
//}
//
//int TestAdd(int a, int b){
// return a + b;
//}
//void TestStdFunc(std::function<int(int,int)> fun, int a, int b){
// auto ret = fun(a, b);
//}
//
//typedef int(*TestAddPtr)(int, int);
//
//void TestPCall(TestAddPtr func, int a, int b){
// auto ret = func(a, b);
//}
//
//struct Vertex{
// bool isgood;
// float x, y, z;
// double dx;
// bool bx;
// int ix;
// bool by;
//};
//void TestFile(){
// int szChar = sizeof(char);
// ofstream ofs;
// ofs.open("f:/test.txt");
// ofs << "hello " << 10 << " world " << 20 << endl;
//
// ofs.flush();
// ofs.close();
//
// ifstream ifs;
// ifs.open("f:/test.txt");
// string str1, str2;
// int num1, num2;
//
// ifs >> str1 >> num1 >> str2 >> num2;
//
// //错误示例：二进制读写，使用std::<<或>>进行的还是ASCII码的读写
// ofstream ofsb;
// ofsb.open("f:/testb", ios::binary);
// ofsb << "hellob" << 1022;
//
// ofsb.flush();
// ofsb.close();
// ifstream ifsb;
//
// string sx;
// int nx;
// ifsb.open("f:/testb", ios::binary);
// ifsb >> sx >> nx;
// ifsb.close();
//
// //正确做法
// sx = "binary";
// nx = 978;
// ofsb.open("f:/testbx", ios::binary);
// ofsb.write(sx.c_str(), sx.length()*sizeof(char)+1);
// ofsb.write((const char*)&(nx), sizeof(int));
// ofsb.flush();
// ofsb.close();
//
// char sxr[32];
// int nxr;
// ifsb.open("f:///testbx", ios::binary);//注意这里的"///"不管有多少个/都等同于一个
// ifsb.read(sxr, sx.length()+1);
// ifsb.read((char*)&nxr, 4);
//
// //数据转换的更通用方式
// Vertex vt;
// vt.bx = true;
// vt.isgood = false;
// vt.x = 12;
// vt.y = 13;
// vt.z = 14;
// vt.dx = 3.9;
// vt.by = 0;
//
// ofstream ofsbx;
// ofsbx.clear();
// ofsbx.open("f:/testbyx2", ios::binary);
// ofsbx.write((const char*)&(vt), sizeof(Vertex));
// ofsbx.flush();
// ofsbx.close();
//
// ifstream ifsbx;
// Vertex vrt;
// ifsbx.clear();
// ifsbx.open("f:/testbyx2", ios::binary);
// ifsbx.read((char*)&vrt, sizeof(Vertex));
//
// string s1 = "hello";
// string s2 = "wrold";
// s1 = s1 + s2;
// auto s3 = s1.substr(1, 2);
//}
//
////实现较为高效的字符串分割，限制是分割符只能是一个字符，不能是一个串
//std::list<string> TestStrSplit(string s, char sep){
// std::list<string> lst;
// for (int i = 0, j = 0; i < s.length(); ++i){
// if (s[i] == sep){
// lst.push_back(s.substr(j, i - j));
// j = i + 1;
// }
// }
//
// //注意临时对象作为返回值了，一般情况下这是错误的用法，栈上的临时对象出了函数域后会被释放
// //但这里STL容器内部重载了=运算符，作了值拷贝就没问题了
// return lst;
//}
//void TestString(){
//
// //g正则表达式实现字符串分割
// string s1 = "a;b;c;dddd;ef;";
// string s2 = "a123b2673cdd4444a";
// std::regex re("(\d+)");
// std::smatch mtch;
//
// //这个做法效率挺低且浪费内存，产生了很多中间字符串
// while (std::regex_search(s2, mtch, re, std::regex_constants::match_default)){
// cout << mtch.str() << endl;
// s2 = mtch.suffix();
// }
//
// //这个函数效率要高多了
// auto lst = TestStrSplit(s1, ';');
//
//}
//
////返回栈上的临时对象测试
//CStudent TestTempObjRet(){
// CStudent ost; //临时对象
// return ost; //调用对象的拷贝构造函数
//}//出了栈后ost被释放，析构函数调用，同时成员对象被析构CStudent.name=""，但内置类型仍保持原值
//
////通过测试可知，将栈上对象作为函数返回值使用一般是没有问题的，但浅COPY时两个对象中的指针指向同一份
////内存，当一个对象被删除时，另一个对象中的指针就指向非法位置了，成了野指针
//void TestObjConstructorAndDestructor(){
// CStudent ostx;
// ostx = TestTempObjRet(); //调用拷贝构造函数（与上面对应）
// auto name = ostx.GetName();
// auto px = ostx.pData;
//}
//
//void TestRRef(){
//
//}
//
////可以使用随机访问（数组下标）说明vector在内存中是连续存放的
////这样，vector在需要扩充容量时就需要将原来内存删除，再申请一块新内存
////但这并不一定，因为内存申请时若用realloc则有可能会在原内存后面增加（原理）
//void TestVector(){
// std::vector<string> sv{ "hello", "world" };
// sv[0];
// sv[1];
//
// sv.reserve(20); //旧的内容被清除
// int n = sv.capacity(); //20
// sv.push_back("a");
// sv.push_back("b");
// sv.clear(); //旧的内容被清除
// n = sv.capacity(); //20
//
// sv.shrink_to_fit(); //内存释放
// n = sv.capacity(); //0
//
//}
//
//struct CTA{
//private:
// virtual void Test(){
// cout << "cta" << endl;
// }
//
//};
//
//class CCTA : CTA{//类和结构体可以相互继承
//public:
// int _id;
// void Test() const{
// cout << "ccta-test" << endl;
// }
//};
//
////C++中字符串有常量和变量之分，字符串遇到\0则结束
////C#中只有常量字符串，字符串遇到\0不结束，视其为正常字符
//void TestStr(){
// char* ps = "hello";//字符串常量，不可修改其内容
// ps[0] = 'd'; //运行出错
//
// char arr[] = "hello"; //字符串变量
// char* par = arr;
// arr[0] = 'd'; //ok
//}
//
////C++中指针字符串与数组字符串都是自动以0结尾的
//void TestMemcpy(){
//
// char dest[18];
// char src[] = "hell"; //以0结尾，长度为5，若强制声明为 char src[4] = "hell"则编译报错
// char* psrc = "hell"; //以0结尾，长度为5，但测试长度strlen(psrc)为4，因为它没算尾0
//
// for (int i = 0; i < 10; ++i){
//
// }
// for (int i = 0, ch; (ch = psrc[i++]) != 0;){
// //这里发现字符串尾0后有许多个0，不知道原因
//
// }
// auto len = strlen(psrc); //4，测试长度，并没字符串的真实长度（内存中真实串），因为它有尾0
// int len2 = strlen(src); //5，字符串实际长度（内存中存储的字符串）
// int st = sizeof(src); //5，数组大小
// memcpy(dest, psrc, strlen(psrc)+1);
//}
//template<typename T1, class T2> class MyVector{
// std::vector<int> _lst;
//
//public:
//
// void Test2();
//};
//
//template<class T1, class T2> void MyVector<T1, T2>::Test2(){
//
//}
#pragma region 2018.7.7
[module(name = "mytestx")];
void TestIOStream() {
std::fstream fs;
fs.open("test.txt", ios_base::in | ios_base::out);
fs << 12 << "hello";
fs.seekp(0);
int ix1;
string sx1;
char chs[6];
fs >> ix1;
fs >> chs;
chs[5] = 0;
sx1 = chs;
cout << ix1 << sx1.c_str() << endl;
}
void TestMacro() {
#define hfunc(x) cout << x << endl; //自定义处起，全局可见
hfunc(124);
#undef hfunc
//typedf, using等价使用
typedef void(*PFUN)(int);
using PFUNC = void(*)(int);
using Int = int;
using MyType = Int;
}
//数组和指针
void TestArrayAndPointer() {
//1,char* p : char类型指针，指向char数组， p++移动一个char
//2,int* p : int型指针，指向int数组，p++移动一个int
//3,char(*p)[2] : char[2]类型指针，指向char[2]类型数组，即char[][2]数组，p++移动一个char[2]
//总结：X类型的指针指向X类型的数组, p++移动一个数组元素
//如何看指针类型：去除*p剩下的就是类型，如char*p去掉*p为char,char(*p)[2]去掉*p为char[2]
//========================================================
//指针总是指向数组的，如下，可认为是指向只有一个元素的数组
//========================================================
int ix = 20;
int*pix = &ix;
cout << pix[0] << "," << *pix << endl;
//========================================================================================
//堆和栈上数组的初始化列表写法
//========================================================================================
char arr[43] = { 'a','b','c' };
char arr2[10] = { "hello" };
int iarr[] = { 1, 2, 3, 4 };
char*ps = new char[30]{ 0 };
int* ips = new int[30]{};
int* ips2 = new int[30];
//cout << arr << "," << (void*)arr << (void*) ps << endl;
char* px;
px = arr; //可以赋值，说明数组名与指针等价
const char* cp;//可以cp++;
char* const cpx = arr; //不可以 cpx++，不能移动的指针，数组名其实就是这种指针
//这里以arr与ps作对比，数组名与指针本质上都是指针，只是数组名是不能移动，不能赋值的常指针
//在二维情形时也是如此
stringstream ss;
//========================================================================================
//1，栈上二维数组，【内存连续】
//========================================================================================
char a[][3] = {//二维数组初始化列表
{ 98, 99, 100 },
{ 101, 102, 103 },
};
for (int i = 0; i < 6; ++i) {//验证
ss << *(*a + i) << ",";
}
cout << ss.str() << endl;
//=============================================================================
//2，数组指针(也称行指针)，【内存连续】
//=============================================================================
int(*pax)[4] = new int[3][4];
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 4; ++j) {
pax[i][j] = i * 4 + j + 1;
}
}
ss.str("");
for (int i = 0; i < 12; ++i) {//验证
ss << *(*pax + i) << ",";
}
cout << ss.str() << endl;
//=============================================================================
//3，指针数组，【内存不连续】
//=============================================================================
//因为它是一个数组，所以不能用new来给它分配内存，new出来的东西只能赋值给指针
char* arr_p[2];
arr_p[0] = new char[30]{ 'h','e','o','l','l' };
arr_p[1] = new char[10]{ 'a','b','c' };
//=============================================================================
//4，多级指针用来分配二维数组，有【连续内存分配法】和【不连续内存分配法】
//这个非常重要，若用一个不连续的二维数组指针进行memcpy操作，则会发生严重问题:
//（1）数据拷越界，覆盖了其它变量甚至程序的内存
//（2）dest变量中数据只填充了一部分，其余部分还是旧数据，导致程序出现莫名其妙的问题
//（3）这种数据拷越界并无任何提示，隐蔽性极高，非常难以查找
//=============================================================================
int**pi = new int*[3];
int* ptemp = new int[12];
for (auto i = 0; i < 3; ++i) {
//------------------------------------------------
//(1)【不连续内存分配法】
//pi[i] = new int[2];
//------------------------------------------------
//(2)【连续内存分配法】
pi[i] = &((ptemp + i * 2)[0]);
for (int j = 0; j < 2; ++j) {
pi[i][j] = i * 2 + j;
}
}
for (int i = 0; i < 3; ++i) {//验证
for (int j = 0; j < 2; ++j)
{
ss << pi[i][j] << ",";
}
}
cout << ss.str() << endl;
}
void TestInitialist() {
class CIn {
public:
float x, y, z;
string name;
};
//初始化列表的使用条件：
//无自定义构造函数，成员公有，无基类，无虚函数
//这么多限制，可以说很鸡肋
CIn oin = { 1, 2, 3, "hello" }; //方式1
CIn oin2 { 1, 2 ,3, "world" }; //方式2
}
#pragma endregion
#pragma region 2018.7.9
class CComplex {
float real, image;
public:
CComplex(float real, float image) {
cout << "constructor: " << real << "," << image << endl;
this->real = real;
this->image = image;
}
CComplex(const CComplex& other) {
cout << "copy constructor: " << other.real << "," << other.image << endl;
if (this != &other)
{
real = other.real;
image = other.image;
}
}
~CComplex() {
cout << "~ccomplex" << "(" << real <<"," <<image << ")" << endl;
// real = 0;
// image = 0;
}
void PrintInfo() {
cout <<"Complex: " << real << "," << image<< endl;
}
public:
//-------------------------------------------
//运算符重载
//-------------------------------------------
//1，重载为成员函数
CComplex operator+(const CComplex& other) {
cout << "operator+" << endl;
return CComplex(real+other.real, image + other.image);
}
CComplex& operator++() {//前向++
cout << "forward ++ " << endl;
real++; image++;
return *this;
}
CComplex& operator++(int) {//后向++
cout << "backward ++ " << endl;
real++; image++;
return *this;
}
const CComplex& operator=(const CComplex& other) {
this->real = other.real;
this->image = other.image;
return *this;
}
//2，重载为友元函数
friend CComplex operator+(float fx, const CComplex& cp);
//3，【运算符重载函数不能定义为静态函数】
//这与C#不同，C#中所有运算符重载都必须是public和static的
//static CComplex operator+(float fx, const CComplex& cp);
//4，类型转换运算符重载
operator bool() {//使用情景：CComplex oc; if(oc){}或if(oc != NULL){}或 float/int/bool x = oc
return real != 0 && image != 0;
}
operator float() {//使用情景：CComplex oc; if(oc){}或if(oc != NULL){}或 float/int/bool x = oc
return real;
}
// CComplex operator=(const CComplex& other) {
// if (this == &other)
// return other;
// return CComplex(other.real, other.image);
// }
void Testx() {
CComplex* pNewCom = new CComplex(2, 2);
pNewCom->real = 20;//可以访问私有成员？？
}
};
// CComplex CComplex::operator+(float fx, const CComplex& cp) {
// return CComplex(fx + cp.real, cp.image);
// }
CComplex operator+(float fx, const CComplex& cp) {
return CComplex(fx + cp.real, cp.image);
}
void TestCComplexOper() {
int i = 10;
CComplex cpx(1, 2);
++cpx++++;
cpx.PrintInfo();
}
CComplex TestReturnStackObj() {
//-----------------------------------------------------------------
//返回栈上的对象 stackObj
//返回栈上的对象会导致拷贝构造函数的调用，生成一个
CComplex stackObj(1, 2);
return stackObj;
return CComplex(1, 2); //这种方式直接调用构造函数，而不调用拷贝构造函数
//-----------------------------------------------------------------
}
#pragma endregion
#pragma region 2018.7.10
void TestRealloc() {
cout << "---------------test-realloc---------------" << endl;
int szch = sizeof(char);
char*pstr = "this is a test str";
int strLen = strlen(pstr);
char* pdesc = (char*) malloc((1+strLen)* sizeof(char));
for (int i = 0; i < strLen; ++i) {
cout << "," << hex<< (int)pdesc[i];
}
cout << endl;
cout << strlen(pstr) << endl;
strcpy_s(pdesc, strLen+1, pstr);
for (int i = 0; i < strLen; ++i) {
if(pdesc[i] > 0)
cout << (char)pdesc[i];
else cout << "," << (int)pdesc[i] ;
}
cout << endl;
pdesc = (char*)realloc(pdesc, 40);
for (int i = 0; i < 40; ++i) {
pdesc[strLen + i] = 'a' + i;
}
for (int i = 0; i < 40 + strLen; ++i) {
if (i < strLen)
cout << pdesc[i] << ",";
else
cout << (unsigned short)pdesc[i] << ",";
}
cout << endl;
cout << "---------------test-realloc---------------" << endl;
}
template<typename T> class CMyNumOperator {
T a, b;
public:
static T Add(T x, T y) {
return x + y;
}
};
#pragma endregion
#pragma region 2018.7.11
#pragma region 继承相关
class A {
public:
A(int x) {
fProtected = x;
}
float GetFProtected() {
return fProtected;
}
public:
float fpublic = 2.3f; //c++11支持了初始化,但不能使用auto
string sname = "liqi";
CMyNumOperator<int>* on = new CMyNumOperator<int>(); //对象也可以
void TestFunc() {
cout << "TestFunc " << fProtected << endl;
}
static void StaticTestFunc() {
cout << "Static-TestFunc" << endl;
}
virtual void ToString() {
cout << "A::ToString" << endl;
}
protected:
float fProtected;
void ProtectedFunc() {
cout << "PRotectedFunc" << endl;
}
private:
void PrivateFunc() {
cout << "PrivateFunc" << endl;
}
};
//只管公有继承，不管保护继承和私有继承，意义不大，也太复杂
//C++可以直接调用构造函数吗？
//可以，有两种
//1，构造函数列表中
//2，new T()构造对象时
class B : public A {
public:
friend void TestProtectedDerive();
B() :A(1) {} //显示调用构造函数【1】
void TestForDerive() {
//公有继承下
//1，子类可以访问父类的保护成员，不能访问父类的私有成员
B ob;
//PrivateFunc(); //error，子类不能访问基类的私有成员
ProtectedFunc(); //right
fProtected = 10; //right
ob.fProtected = 20; //right
A* pa = new A(1); //显示调用构造函数【2】
}
//1，c++中只要基类有相同签名虚函数，则默认为此基类函数也是虚函数[与C#不同]，如下情形都成立
// (1) 函数不声明 virtual
// (2) 函数声明了 virtual
// (3) 函数声明了 override
// (4) 函数声明了 virtual 和 override
//2，c++中两个关键词作用不同，可以同时存在
// virtual仅表明函数是虚函数，override是C++11中出现的，明确说明是对基类的重写
// 它的好处是当函数声明不符合规则时，编译器会报错
void virtual ToString() override{
cout << "B::ToString" << endl;
}
};
void TestProtectedDerive() {
B ob;
ob.ProtectedFunc();
}
#pragma endregion
#pragma endregion
#pragma region 2018.7.18
#pragma region 标准输入流
void TestCinCout() {
float fx;
std::string str;
while (true) {
bool errorNum = false;
cin >> str; //1，试读，看是不是"exit"串
if (str == "exit")//2，若是，结束循环
break;
for (int i = str.length() - 1; i >= 0; --i) {//3，若不是，将串放回到流中，注意是反向放回的
cin.putback(str[i]);
}
cin >> fx;
if (cin.fail()) {//4，如果格式错误
cout << "格式错误：请输入一个数值" << endl;
cin.clear(); //5，清除错误标识
while (cin.get() != '\n'); //6，读掉后面出错的所有字符，直到回车
errorNum = true;
}
if (!errorNum) {//7，若前面输入（数字）是正确的，则继续后面的解析
cin >> str;
if (cin.fail()) {
cout << "格式错误：请输入一个字符串" << endl;
cin.clear();
}
cout << ">>数值= " << fx << ", 描述= " << str << endl;
}
}
}
#pragma endregion
#pragma region 计算机数据存储
void TestComputeDataStorage() {
//数据转换：C++，C# 通用
//1，整形数据：短数据类型转长数据类型时，正数高位补0，负数高位补1
//2，浮点形数据转整形时，得到整数部分，舍去了小数部分
cout << hex;
cout << (int)(short)1 << endl; //1，即 0x00000001
cout << (int)(short)-1 << endl; //0xffffffff，即负数高位补1
cout << -1 << endl; //0xffffffff，负数表示法，符号位1，真值（1）求补码
auto sz = sizeof(long);//64位系统，X64编译器下VS2017测试值为4
float fx = 83.7f;
auto lfx = (long unsigned int)fx; //浮点转整形，
long long x; //8位整形
long unsigned int lui; //8位无符号整形
//浮点数据字节察看
//125.5f = 0x42fb0000
//-125.5f = 0xc2fb0000
//83.7f = 0x42a76666
//浮点数存储按IEEE754标准：
//以float为例：共4个字节，从高位到低位依次是31,30,...2,1,0
//最高位存放数据符号，接下来8位存放阶码（包括阶码符号位），接下来23位存放尾数
int ifx = *(int*)(&fx);
//等价于
int* pfx = (int*)&fx;
int ipfx = *pfx;
int sz2 = sizeof(x);
}
#pragma endregion
#pragma region 地址与指针
void TestAddrAndPointer() {
//-------------------------------------------------------------
//1，&p, p, *p的区别: &p是p的地址，p是一个地址，*p是地址中的内容
//2，地址与指针完全等价，有两种操作：*地址，地址->
//3，地址就是一个数值，指针也是个地址
int x = 10;
*(&x) = 0x100;
*((char*)&x) = 1; //小端模式下[低字节存低地址处，高字节存高地址处]：0x101
int* pxt = (int*)10; //直接指向内存地址0x0000000a处
int*px = &x; //px与 &x完全等价
int adr = (int)(&x); //地址就是个数值，指针也是个地址值
px = (int*)adr;
cout << hex; //输出为16进制
cout << adr << "," << &x << "," << (int*)&x << "," << px << endl; //四者等价，输出相同值
cout << dec; //输出为10进制
A oa(0);
(&oa)->fpublic = 30; //地址与指针等价
(*(&oa)).fpublic = 111; //地址与指针等价
}
#pragma endregion
#pragma region 函数指针
void TestFuncPtr() {
cout << "TestFuncPtr" << endl;
}
void TestFuncPtrParam(int, int, int) {//注意函数参数可以不写变量名
void(*pf)(int, int, int) = TestFuncPtrParam;
int*p = (int*)pf;
//试图找出函数实参,失败，对函数汇编原理不清楚，有时间再查
cout << *(p) << "," << *(p-1) << endl;
}
void TestFuncPointer() {
A oa(0);
//1，函数指针与普通指针不兼容，不能相互强转
//2，函数指针赋值方式有二：pf = func或 pf = &func
//3，函数指针pf使用方式有二：pf()或 (*pf)()，因为pf和 *pf的值相同，调试模式下可以看到
//1，普通成员函数指针
typedef void(A::* PFUNC)(void); //函数指针声明方式一
using PFunc = void(A::*)(void); //函数指针声明方式二，C++11新方式
PFunc pf = &(A::TestFunc);
int pfsz = sizeof(pf);
(oa.*pf)();
//2，全局函数指针
void(*pfg)() = TestFuncPtr;
pfg();
(*pfg)();
//3，静态函数指针
void(*sptf)() = A::StaticTestFunc;
sptf();
(*sptf)();
}
#pragma endregion
#pragma region 虚函数表原理
//每一个带有虚函数的【类】都有一个虚函数表，注意不是对象
void TestVirtualFunctionTable() {
cout << hex;
typedef void(*PFUNC)();
offsetof(A, fpublic); //利用此函数可以算函数布局
A oa(0);
B ob;
//一，通过内存地址修改不可访问的保护变量
*(float*)((int*)&oa + 1) = 123.4f; //类的第一个变量fpublic赋值，(int*)&oa + 1是跳过虚函数指针
float fpublic = oa.fpublic;
//二，通过内存地址调用虚函数
//A和B的虚函数表地址不一样，也就是说父类和子类各有一张虚函数表
int* pvptr = (int*)(*((int*)(&oa)));
cout << "A的虚函数表地址:" << pvptr << endl; //000DB0D4
((void(*)())(*pvptr))(); //A::ToString
pvptr = (int*)(*((int*)(&ob)));
cout << "B的虚函数表地址:" << pvptr << endl; //000DB128
((void(*)())(*pvptr))(); //B::ToString
cout << "--------------------------" << endl;
//最简写法
((void(*)())(*((int*)*(int*)&oa)))();
((void(*)())(*((int*)*(int*)&ob)))();
}
#pragma endregion
#pragma region 函数对象，友元函数模板运算符重载
template<class T>
class AddTwoNumber {
public:
T x;
AddTwoNumber(T x) {
this->x = x;
}
public:
//【通过重载()运算符，实现函数对象】
T operator()(T a, T b) {
return a + b;
}
//一，使用模板类型的友元模板函数
//1， <>表示该友元是一个模板函数，且使用本模板类的类型
// 若不加<>说明符，则找不到模板函数定义，运行时出错
//2，这里的T是模板类传来的类型，因此，这里不能实现与T不同的类型操作
//比如若T为int，则 2.1f + new AddTwoNumber<int>()不合法
//3，【注意这里第二个参数是个引用类型，若是AddTwoNumber<T>对象类型则会出错，不能在类中定义本类对象】
friend void operator+ <>(T os, AddTwoNumber<T>& n);
//二，使用模板函数自带类型的友元模板函数
//这里的T是一个新的类型，与此模板类的T没关系，因此没有上面的限制
template<class T>
friend void operator+(T os, A oa);
template<class T>
T Add(T a, T b);
};
template<class T>
void operator+ <>(T os, AddTwoNumber<T>& n) {
cout << "operator+: n + AddTwoNumber: " << os << endl;
}
template<class T>
void operator+(T n, A o) {
cout << "operator+: n + A : " << n << endl;
}
//==================================================
//※※※※※※注意这种多层的模板前置声明※※※※※※※
template<typename T> //类模板的前置声明
template<typename T1> //函数模板的前置声明
T1 AddTwoNumber<T>::Add(T1 a, T1 b) {
return a + b;
}
void TestAdd2Num() {
AddTwoNumber<double> NumAdd(1);
auto nadd = NumAdd(1, 2);
A oa(1);
2.1f + oa; //左操作数任意数值类型，因为使用的是模板函数自带类型
2.0 + NumAdd;//左操作数必须为double，
AddTwoNumber<string> add2("str");
add2.Add(1, 1);
cout << "x: " << add2.x << endl;
}
#pragma endregion
#pragma endregion
#pragma region 2018.7.19
#pragma region 智能指针
//----------------------------------------------------------------------------------------------
template<typename T>
class SmartPointerx {
private:
T * _ptr;
size_t* _count;
public:
SmartPointerx(T* ptr = nullptr) :
_ptr(ptr) {
if (_ptr) {
_count = new size_t(1);
}
else {
_count = new size_t(0);
}
}
SmartPointerx(const SmartPointerx& ptr) {
if (this != &ptr) {//永远成立
this->_ptr = ptr._ptr;
this->_count = ptr._count;
(*this->_count)++;
}
}
SmartPointerx& operator=(const SmartPointerx& ptr) {
if (this->_ptr == ptr._ptr) {
return *this;
}
if (this->_ptr) {
(*this->_count)--;
if (this->_count == 0) {
delete this->_ptr;
delete this->_count;
}
}
this->_ptr = ptr._ptr;
this->_count = ptr._count;
(*this->_count)++;
return *this;
}
T& operator*() {
assert(this->_ptr == nullptr);
return *(this->_ptr);
}
T* operator->() {
assert(this->_ptr == nullptr);
return this->_ptr;
}
~SmartPointerx() {
(*this->_count)--;
if (*this->_count == 0) {
delete this->_ptr; //数组内存泄漏 int*p = new int[10]
delete this->_count;
}
}
size_t use_count() {
return *this->_count;
}
};
void TestSmartPtr() {
{
SmartPointerx<int> sp(new int(10));
SmartPointerx<int> sp2(sp);
SmartPointerx<int> sp3(new int(20));
sp2 = sp3;
std::cout << sp.use_count() << std::endl;
std::cout << sp3.use_count() << std::endl;
}
//delete operator
}
//----------------------------------------------------------------------------------------------
//下面是一个简单智能指针的demo。智能指针类将一个计数器与类指向的对象相关联，
//引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；
//当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；
//对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），
//并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。
//智能指针就是模拟指针动作的类。所有的智能指针都会重载->和 * 操作符。
//智能指针还有许多其他功能，比较有用的是自动销毁。
//这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存
template<class T>
class SmartPointer final{ //final
T* pobj = NULL;
__int64* refCnt = 0;
public:
SmartPointer(T* pobj) {//这里可能会传一个栈对象地址
if (pobj) {
if (pobj != this->pobj) {
if (!this->pobj)
this->pobj = new __int64;
(*refCnt)++;
this->pobj = pobj;
}
}
}
SmartPointer(const SmartPointer<T>& rhs) {
operator=(rsh);
}
SmartPointer<T> operator=(const SmartPointer<T>& rhs) {
if (this == &rhs || pobj == rhs.pobj)
return rhs;
(*refCnt)--;
(*rhs.refCnt)++;
pobj = rhs.pobj;
return *this;
}
~SmartPointer()
{
refCnt--;
if(refCnt == 0)
ReleaseRes();
}
T* GetPtr() const {
return pobj;
}
private:
void ReleaseRes() {
if (pobj) {
try
{
delete[] pobj;
pobj = NULL;
}
catch (const std::exception&)
{
cout << "智能指针指向的不是一个堆对象" << endl;
}
}
}
};
#pragma endregion
#pragma endregion
#pragma region 2018.7.23
#pragma region 数组传参方式
//方式一，数组引用传递
template<int N>
void ArrayRefAsParam(char(&_dest)[N]) {//数组引用的写法
char chs[] = "hello";
char* pstr = "hello";
cout << sizeof(chs) << endl;
cout << strlen(chs) << ", " << strlen(pstr) << endl;
strcpy_s(chs, "world");
cout << chs << endl;
}
//方式二，指针传递
void PointerAsParam(const char* pArr, int elemCount) {
}
void TestAstrPstr() {
char chs[] = "world"; //6个字符，自动加了一个尾0
//1，数组引用传参，以下两种方式等价
ArrayRefAsParam(chs); //模板不仅可以推导类型，也可以推导出数组的大小
ArrayRefAsParam<6>(chs); //说明了模板的工作原理，可以不写6，模板自动推导出数组大小
//2，指针传递
int sz = sizeof(chs); //6
int slen = strlen(chs); //5
PointerAsParam(chs, 1 + strlen(chs));
}
#pragma endregion
#pragma region 静态(变量与函数)与常量(常引用，常指针，常函数)
class CWithConstStatic {
private:
static int _privateId;
public:
string _str = "CWithStatic";//C++11，可以这样初始化
static string _sstr; //静态变量不允许在类内初始化，这与旧C++一致
int _id = 1010;
public:
static void StaticMethod(){
//1，静态函数本质上是一个全局函数
//2，静态函数不能访问非静态变量和非静态函数，包括常函数及常量，因为它不属于对象，没有this指针，编译器翻译时出错
// _id = 10; //不访问非静态变量，因为没有this指针，不翻译为this->_id
//ConstMethod();//不能访问非静态函数，因为没有this指针，不翻译为 this->ConstMethod()
}
void ConstMethod() const {//1
auto id = this->_id;
StaticMethod(); //可以访问静态函数，因为静态函数不可能更改对象
//NormalMethod(); //不能访问普通函数，因为普通函数可能会更改对象
}
void ConstMethod() {
//注意1和2的两个ConstMethod函数是重载关系
}
void NormalMethod() {//若函数从【调用1】处进入，则有：
cout << "normal method begin" << endl; //输出，没问题
//cout << _id << endl; //出错，因为这里等价于 this->_id，而this指针为NULL
}
};
string CWithConstStatic::_sstr; //静态变量在类外的CPP中声明
void NormalMethod(CWithConstStatic* _this) {
}
void TestCWithStatic() {
//1，常对象
const CWithConstStatic ow;
//ow._id = 1001; //error, 常对象不能被修改
//ow._str = "dd"; //error, 常对象不能被修改
ow._sstr = "dd"; //ok, 静态变量不属于对象
//2，常引用
const CWithConstStatic& owRef = ow;
//owRef._str = "hhh"; //error, 常引用不能被修改对象
owRef._sstr = "dd"; //ok, 静态变量不属于对象
//3，常量指针，指向常量的指针，指向的内容不可修改
const CWithConstStatic* pcwcs = new CWithConstStatic();
//pcwcs->_id = 20; //error，不可通过常指针更改其指向的内容
//4，指针常量，指针是一个常量，不可被再次赋值
CWithConstStatic* const cpcwcs = new CWithConstStatic();
cpcwcs->_id = 20; //ok
//5，类函数原理，this指针
//c++类的成员函数被编译器翻译为了C语言编译器可以识别的全局函数，然后用C语言编译器来处理它
//以下两条调用等价
CWithConstStatic* pwcs = NULL;
pwcs->NormalMethod(); //【调用1】C++的样子
NormalMethod(pwcs); //【调用2】C语言翻译出来的结果
}
#pragma endregion
#pragma region 深入模板
#pragma region 可变参数模板
void TestVarTemp() {//【无参的重载函数】
//这个函数必须定义，否则编译器报错，因为函数参数展开时，最终（可变参数个数为0时）要调用此函数
}
template<typename First,
typename... Args
>
void TestVarTemp(First first, Args... args) {
//sizeof...是可变参数模板专用的获取参数个数的函数
cout << sizeof... (args) << "-" << first << " ";
//可变参数展开的唯一方式是递归调用，一层层剥离参数，当参数个数为0时调用无参的重载函数，见【无参的重载函数】
TestVarTemp(args...);
}
void TestVarTemplate() {
TestVarTemp(1, 2, 3, 4, "hello");
}
#pragma endregion
#pragma endregion
#pragma region 构造和拷贝构造
class CNormclass {
public:
CNormclass() {
cout << "constructor" << endl;
}
CNormclass(const CNormclass& rhs) {//有了复制构造函数后，系统不再为类生成无参构造函数
cout << "copy-constructor" << endl;
*this = rhs;
}
};
CNormclass TestConstructorAndCopyCon1() {
return CNormclass();//不调用COPY构造函数
}
CNormclass TestConstructorAndCopyCon2() {
//对象定义：两种不同的定义方式
//方式一，会调用两次构造函数
CNormclass r0; //constructor
r0 = CNormclass(); //constructor，注意不是COPY构造函数
//方式二，只调用一次构造函数
CNormclass rr = CNormclass(); //constructor
//COPY构造函数仅在两种情况下调用：
//1，将一个已存在的对象生成另外一个对象
CNormclass r1 = r0; //拷贝构造
//2，将一个已存在的对象作为参数传递给构造函数时
CNormclass r2(r0); //拷贝构造
//不调用构造函数，也不调用拷贝构造函数，也不调用=运算符（因为是同类型），只是进行按位copy
r1 = r0;
cout << "before return " << endl;
return rr; //调用COPY构造函数
}
#pragma endregion
#pragma region 函数指针复杂嵌套
typedef int(*PF2)(int);
typedef PF2(*PF1)(int, int);
typedef PF1(*PF)(int);
int func2(int) {
cout << "func2" << endl;
return 0;
}
PF2 func1(int, int) {
cout << "func1" << endl;
return func2;
}
PF1 funcx(int) {
cout << "funcx" << endl;
return func1;
}
void TestNestingFuncPtrs() {
//1，一次嵌套
PF1 pf1 = func1;
pf1(1, 2)(1);
//等价方式的直接声明
int(*(*ptr)(int, int))(int) = func1;
ptr(2, 3)(4);
cout << "--------------------" << endl;
//2，二次嵌套
PF pf = funcx;
pf(1)(2, 3)(2);
//等价方式的直接声明
int(*((*((*ptr2)(int)))(int, int)))(int) = funcx;
ptr2(1)(2, 3)(2);
}
#pragma endregion
#pragma region 类型转换构造函数
class CTypeCast {
public:
int _id;
string _name;
CTypeCast(int i) {//整形转换构造函数：将一个整形转为对象
_id = i;
cout << "integer cast " << i << endl;
}
CTypeCast(string str) {//字符串转换构造函数：将一个字符串转为对象
_name = str;
}
//注意，显示声明，转换必须显式进行
explicit CTypeCast(float fx) {//浮点转换构造函数：将一个字符串转为对象
cout << "float cast " << fx << endl;
}
};
void TestTypecastContructor() {
//CTypeCast otc = 1; //整形转换构造函数
//CTypeCast otc2 = "otc2"; //字符串转换构造函数
//otc = 3;
//注意，当加了explicit后，类型转换必须显示进行，因此下面这个语句不会使用浮点转换构造函数
//但是，它却可以使用整形转换构造函数，这会造成数据精度丢失
CTypeCast otc3 = 3.2f; //隐式转换：整形转换构造函数
CTypeCast otc4(3.2f); //显示转换：浮点转换构造函数
}
#pragma endregion
#pragma region 2018.7.24
#pragma region 类型转换运算符及()[]重载
class CTypeCastOper{
float fx = 0.2f;
int arr[3]{ 1,2,3 };
public:
//1，类型转换运算符
explicit operator float() {
return fx;
}
operator string() {
}
//2，()重载
//()运算符并不是用来做类型转换的，它是当函数用的，即仿函数，或函数对象
bool operator()() {
return true;
}
//3，[]重载
//[]运算符与()差多的用法，都是用于对象之后
int operator[](int idx) {
return arr[idx];
}
};
void TestTypecastOper() {
CTypeCastOper oper;
float fx = (float)oper;
cout << fx << endl;
//1，()运算符
bool b = oper();
//2，[]运算符
cout << oper[0] << "," << oper[1] <<"," << oper[2] << endl;
}
#pragma endregion
#pragma region 模板特化
template<typename T>
class CTehuaTemp {
public:
T px = "abc";//2，被特化为了一个char*类型指针，故可以这样用
};
template<typename T>
class CDThhuaTemp : public CTehuaTemp<T*> {//1，将基类模板参数特化为一个指针类型
public:
T ch = 'c';
};
void TestTehuaTemp() {
CDThhuaTemp<char> otp;
cout << otp.px << endl;
cout << otp.ch << endl;
}
#pragma endregion
#pragma region 同类型赋值，常引用修改
class CSimpleclass {
public:
CSimpleclass() {
cout << "cons" << endl;
}
CSimpleclass(const CSimpleclass& rhs) {
cout << "copy cons" << endl;
}
public:
float fx = 0; //默认未初始化,给它来个初始化
};
void TestSameTypeAssign() {
CSimpleclass oc, oc1;
const CSimpleclass& oc2 = oc;
const CSimpleclass& oc3 = oc;
cout << "-------------------------" << endl;
//【同类型赋值，不调用=运算符，也不调用任何构造函数】
oc1 = oc;
//oc2 = oc3; //常引用本身是个常量，也不能被修改
//oc2 = oc1; //常引用本身是个常量，也不能被修改
//oc2.fx = 30; //常引用不能更改引用的对象内容
const std::string ss;
//ss = "abc"; //wrong
//ss.clear(); //wrong
}
#pragma endregion
#pragma region 堆指针栈指针判断
class CTestPointerType {
public:
CTestPointerType(float fx=0) {
this->fx = fx;
}
float fx;
};
template<class T, int N>
class CHeapDebugger {
public:
static void Print(const T* p){
int sz = N * sizeof(T);
int* ip = (int*)p;
int headFlag = *(ip - 1);
int endFlag = *(int*)((char*)ip + sz);
int orderFlag = *(ip - 2);
int szFlag = *(ip - 3);
bool isHeapPtr = headFlag == endFlag && headFlag == 0xfdfdfdfd && sz == szFlag;
cout << "----------------------------------------------" << endl;
//if (isHeapPtr) {
cout << hex << "堆大小：" << szFlag << endl;
cout << "堆编号: " << orderFlag << endl;
cout << "堆首界: " << headFlag << endl;
cout << "堆尾界: " << endFlag << endl;
//}
//else {
// cout << "栈指针" << endl;
//}
cout << "----------------------------------------------" << endl;
}
};
void TestPointerType() {
//
const int N = 4;
int*p = new int[N];
for (int i = 0; i < N; i++)
{
p[i] = i;
}
CNormclass* pn = new CNormclass[N];
CTestPointerType*po = new CTestPointerType[N];
const int*pc = &N;
CHeapDebugger<int, 1>::Print(&N);
int a = 10, b = 11;
float fx = 20, fy = 30;
CHeapDebugger<int, 1>::Print(&a);
CHeapDebugger<int, 1>::Print(&b);
CHeapDebugger<float, 1>::Print(&fx);
CHeapDebugger<float, 1>::Print(&fy);
delete po;
}
#pragma endregion
#pragma endregion
#pragma region 右值引用和MOVE
void TestRef(){
int a = 0, b = 1;
int& ra = a;
cout << ra << endl; //0
ra = b; //此时ra不是a的引用也不是b的引用，而是一个普通变量
b = 300;
cout << ra << endl; //1
}
#pragma endregion
#pragma region C11智能指针
#pragma endregion
#pragma region 正则表达式
#pragma endregion
#pragma region lambda表达式
#pragma endregion
#pragma region unorder_map及hashtable实现
//有没有无冲突哈希算法
#pragma endregion
#pragma region DIJKASTRA最短路径算法
class Obj {
public:
Obj(float fx) {
x = fx;
}
float x;
};
bool cmpfunc(Obj a, Obj b) {
return a.x < b.x;
}
void TestStlSortFunc() {
std::vector<Obj> vec;
vec.push_back(Obj(1));
vec.push_back(Obj(12));
vec.push_back(Obj(1.3f));
vec.push_back(Obj(2.31));
vec.push_back(Obj(31));
vec.push_back(Obj(4));
vec.push_back(Obj(0));
int ax = 123;
auto iter = max_element(vec.begin(), vec.end(), [ax](Obj obj1, Obj obj2){
cout << "cap addr of ax : " << ax << endl;
return obj1.x < obj2.x;
});
cout << (*iter).x << endl;
}
void RemoveVecElem(std::vector<int>& v, int e) {
for (auto it = v.begin(); it != v.end();) {
if (*it == e)
{
it = v.erase(it);
break;
}
else
it++;
}
}
void Dijkastra() {
const int m = 99999;
const int n = m;
const int nodeCount = 7;
int paths[][nodeCount] = {
{ n, 50, 12, m, 45, m, m },
{ m, n, m, m, 2 , m, m },
{ m, 10, n, 99, m , m, m },
{ m, m, m, n, m , m, m },
{ m, m, m, 10, n , m, m },
{ m, m, m, m, 0 , n, 1 },
{ m, 1, m, m, m , m, n },
};
std::vector<string> sel;
std::vector<int> left{ 0, 1, 2, 23, 4, 15, 6 };
sel.reserve(8);
left.reserve(8);
int startIdx;
cout << ">> 选择一个起点 " << endl;
cin >> startIdx;
cout << ">> v" << startIdx << endl;
if (startIdx >= nodeCount)
return;
RemoveVecElem(left, startIdx);
cout << "after erase : " << left.capacity() << endl;
for (auto e:left)
{
cout << e << ",";
}
cout << endl;
cout << ">> calculating ..." << endl;
int tmp[nodeCount];
for (int i = 0; i < nodeCount; ++i) {
tmp[i] = paths[startIdx][i];
}
std::stringstream ss;
//ss >> "v" >> startIdx;
auto iter = min_element(tmp, tmp + nodeCount);
cout << *iter << "," << iter - tmp << endl;
int curMinNode = iter - tmp;
int curMinPathLen = *iter;
// ss >> "->v" >> curMinNode;
//sel.push_back(ss.str());
//ss.clear();
RemoveVecElem(left, curMinNode);
while (left.size() > 0) {
bool isfind = false;
for (int i = 0; i < nodeCount; ++i) {
int p1 = paths[startIdx][i];
for (int j = 0; j < nodeCount; ++j) {
bool isold = false;
for (int i = 0; i < left.size(); ++i) {
if (left[i] == j)
isold = true;
}
if (!isold) {
int p2 = paths[curMinNode][j];
if (j != curMinNode) { //j != curMinNode
if ((curMinPathLen + p2) < p1) {
isfind = true;
paths[startIdx][i] = (curMinPathLen + p2);
}
}
}
}
}
if (left.size() == 0)break;
auto p = paths[startIdx];
auto iter2 = std::min_element(left.begin(), left.end());
curMinPathLen = *iter2;
//curMinNode = iter2 - left.be;
RemoveVecElem(left, curMinNode);
cout << "left: " << left.size() << endl;
}
// sel.push_back(0);
// sel.erase(sel.begin());
// sel.shrink_to_fit();
// cout << "cap: " << sel.capacity() << endl;
// for (int d : sel)
// {
// cout << d << endl;
// }
// cout << sel.size() << endl;
}
#pragma endregion
#pragma region EffectiveC++
namespace EffectiveCpp {
#pragma region 02-以const,enum,inline替代define
class CStaticConst {
public:
//【1】，static const 可以同时存在，这在C#中是不允许的
//在C#中，常量也是属于类而不属于对象，这就等价于C++的 static cosnt 合体了
static const float fx; //【声明式】
//【2】，浮点类型，不能在定义时初始化
//static float fx2 = 3; //【错误】
//【3】，整数类型（整形，char,枚举)，可以在定义时初始化，且不需要在类外写定义式
static const int ix = 3; //声明并初始化，注意，这不是定义，也就是说声明时可以赋值
enum {NumTurns = 5};
int scores[NumTurns]; //enum hack
//【不安全宏的替代品】，既有宏的高效率和函数的安全性
template<typename T>
inline T safe_max(const T& a, const T& b) {
return a > b ? a : b;
}
virtual void VFunc() {
}
};
const float CStaticConst::fx = 1; //【定义式】：不能写static
//const int CStaticConst::ix = 3; //【错误】，已经初始化过了，不能重复
const int CStaticConst::ix; //定义式，声明时已初始化了。因为是整数类型，这个定义式可以不写
//1，【宏是不安全的】任何时候都不要忘了给宏的实参加上()
//2 替代方法：使用 template inline
#define unsave_max(a, b) (a) > (b) ? (a) : (b)
void Test02() {
CStaticConst oc;
cout << oc.fx << endl;
int a(10), b(20);
//不安全的宏，下面这样的导致b被加两次
max(++a, b++);
cout << "a=" << a << ", b=" << b << endl;
string s1 = "hello";
string s2 = "hello";
}
#pragma endregion
}
#pragma endregion x
#pragma region 2018.8.2
#pragma region 协变逆变
template<typename T>
class CAnimal {
public:
void Print(T info) {
cout << info << endl;
}
};
template<typename T>
class CHuman : public CAnimal<T> {
};
void TestXiebian() {
int a[10], b[10];
float c[10];
int*p = a;
int*p2 = b;
//int*p3 = c; //error
A* pa = new B[10]; //协变
//协变在C++模板中似乎不能用，不像C#
CAnimal<A>* panim = new CHuman<A>[10]; //正确，这个还是普通的数组协变，而不是像C#那样真正的泛型协变
//CAnimal<A>* panim = new CAnimal<B>[10]; //错误
//CAnimal<A>* panim = new CHuman<B>[10]; //错误
}
#pragma endregion
#pragma endregion
#pragma region 2018.8.3
#pragma region 奇怪的默认构造函数和子父间对象赋值
class CA {
public:
float fx;
CA(float x) {
fx = x;
}
virtual void tostring() /*final*/ {//可加final禁止重写
cout << "ca" << endl;
}
};
class CB : public CA {
public:
float fbx = 2;
explicit CB() :CA(1) {
}
//拷贝构造函数可以有两个，常量的，非常量的
CB(CB& b) : CA(1) {//拷贝构造函数1，
cout << "copy 1" << endl;
}
CB(const CB& b) : CA(1) {//拷贝构造函数
cout << "copy 2" << endl;
}
// void tostring() {
// cout << "ca" << endl;
// }
};
CB b() {
cout << "....function...b...." << endl;
return CB(); //【标记1】调用无参构造函数
}
void TestOddConstructor() {
CA a(1);
CB b(); //调用无参构造函数？？错，其实是声明了一个返回值为B的函数o()，对比【标记1】
CB bx; //ok，调用默认构造函数构造了一个对象bx
CB* pb = new CB(); //ok，调用默认构造函数构造了一个对象
//C++中，子对象可以赋值给父对象，C#中也可以，不过C#操作的是指针
a = bx; //子对象可以直接赋值给父对象，发生类截断，子类部分被丢弃
//bx = (CB)a; //error，编译出错，不能转换，除非自定义转换
//bx = static_cast<CB>(a);
CB rb = b();
cout << rb.fx << endl; //正确输出: 1
//CB* pb1 = new CB; //ok，调用无参构造函数
//CB* pb2 = new CB(); //ok， 调用无参构造函数
CB ob1;
const CB ob2;
//拷贝构造函数可以有两个，常量的，非常量的
CB ob3(ob1); //copy 1
CB ob4(ob2); //copy 2
}
#pragma endregion
#pragma region 四种类型转换
class CMemory {
public:
int x;
float fx;
char ch = 'a';
};
class ConstFuncForcemodify {
float fx = 998;
public:
void PrintNum() const {
cout << --(const_cast<ConstFuncForcemodify*>(this))->fx << endl; //去除常量性，或直接使用旧式强转
//cout << --((ConstFuncForcemodify*)this)->fx << endl;
}
};
void Test4Typecast() {
CA a(1);
CB b;
//------------------------------------------------------------------
//一，静态类型转换 static_cast， 【任何类型：值，指针或引用】
//不能将const类型转为non const类型
//1，普通类型转换
int i = static_cast<int>('a'); //等价x = (int)'a';
char c = static_cast<char>(i); //等价c = (char)x;
//a = b; //本身可以转换，子类转换父类
a = static_cast<CA>(b); //ok
a = static_cast<CB>(b); //ok
//b = static_cast<CB>(a); //error，编译错误
//2，指针类型转换，只检查有无父子关系，不进行动态类型检查
//动态类型即运行时，指针实际指向的类型
CB* pb = static_cast<CB*>(&a); //ok，但运行时访问CB类（不属于CA）的部分将出错
pb = (CB*)&a; //等价于上式
cout << pb->fbx << endl; //输出一个未初始化的或不可预料的值
CA* pa = new CB();
pb = static_cast<CB*>(pa);
cout << pb->fbx << endl; //ok
//------------------------------------------------------------------
//二，动态类型转换 dynamic_cast，【用于指针或引用】
//【基类必须定义了虚函数，说明动态时类型检查是根据虚函数表来做的】
pb = dynamic_cast<CB*>(&a); //编译OK，但运行时转换失败pb = Null
//pb = (CB*)&a; //等价于上式
if(pb)pb->tostring();
//------------------------------------------------------------------
//三，重新解释转换reinterpret_cast, 【任何类型：值，指针或引用】
//依赖于编译器，不可移植
void (*pf)() = Test4Typecast;
int* ipf = (int*)pf;
int ix = reinterpret_cast<int>(pf); //将指针转为int，或直接转换
ix = (int)pf;
cout <<hex << "ix: " << ix << ", addr: " << pf << endl;
int* pix = reinterpret_cast<int*>(102);//将整形转换为指针，或直接转换
pix = (int*)102;
//-------------------------------------------------------------------
//四，常量指针转换，移除指针的常量性, 【用于指针或引用】
const int ctx = 10;
int* itx = const_cast<int*>(&ctx); //将常指针转为int*指针，或直接转换
itx = (int*)&ctx;
//测试通过转换去除常指针，在类的常函数中修改成员变量的值
ConstFuncForcemodify ocffd;
ocffd.PrintNum(); //997
ocffd.PrintNum(); //996
ocffd.PrintNum(); //995
}
#pragma endregion
#pragma region 内存布局-参考[堆指针栈指针判断]
//1，程序总布局，内存从高地址向低地址分配，
//2，对象，结构，数组内部的元素从低地址向高地址分配
//分配顺序是变量定义的先后顺序
//本机测试中，任何两个独立数据间的地址间隔为12
class CT {
public:
int x = 101, y = 102, z = 103;//默认公有
void testd() {
cout << x << "<" << y << "<" << z << endl;
}
};
class MyStruct : public CT
{
public:
//===========================================================================
//通用规则，基类指针或引用只能看到基类变量与函数，C++与C#都是这样
//===========================================================================
//如：CT * pt = new MyStruct()，则pt->只能看到基类数据与函数
int y = 1, z = 2, w = 3, h = 4, k = 5; //与基类重名，pt->x是基类的，pt->w则错误，找不到这个变量
};
void TestMemLayout() {
//不相关的各元素，内存从高到低分配，不连续
int x, y, z, w, o, p, q, r, s;
cout << "addr>>" << &x << "," << &y << "," << &z << "," << &w << "," << &o << "," << &p << "," << &q << "," << &r << "," << &s << endl;
//分配完上面的一些独立数据后，内存地址减12，继续分配数组
//数组之内，各元素内存地址从低到高，连续，此时数组的最大地址要小于上面已分配的最小地址
int iarr[10];
for (int i = 0; i < 10; ++i) {
cout << &iarr[i] << endl;
}
//分配完上面的数组，内存地址减12字节，继续分配对象数据
//对象内，各元素内存地址从低到高，连续，最大地址小于上面的最小地址
CMemory om;
cout << &om.x << endl;
cout << &om.fx << endl;
cout << &om.ch << endl; //输出乱码，对字符地址操作默认为是输出字符串
cout << (char*)&om.ch << endl; //同上输出乱码，对字符地址操作默认为是输出字符串
cout << (int*)(&om.ch) << endl; //输出地址
//=========================================================================================
//内存覆盖实验
//利用上面的12差规律，覆盖内存数据
//12差规律，也就是说每两个不相关的数据间有8个字节用来CCCC填充，表示内存分界，内存分界不能写入，否则崩溃
//=========================================================================================
int poorA = 1;
int poorB = 2;
int poorC = 4;
//==========================================================================
//CT* pt = new CT(); //堆上数据被默认初始化为0: x=y=z=0
CT ot;//栈上数据未初始化
//==========================================================================
//查看汇编代码时可以发现，编译器每进一个函数时就会行标记一段内存，每个字节能写入0XCC，这个值就是21号中断
//这样做是为了给开辟的内存做上标记，只允许编译器来在这段内存上分配内存，不允许非法的操作
//如，程序定义了 int a=1，则编译器给 a分配4个字节，并将1写入，若通过指针访问未被赋值的内存，则它里面的内容就是0xcc
//，访问时立即触发21号中断，程序报错，内存不可访问
MyStruct* pms = static_cast<MyStruct*>(&ot); //或 pms = (MyStruct*)(&ot)
//pms->y = 11; //触发21中断
//pms->z = 12; //触发21中断
pms->w = 0; //不是内存分界，可以覆盖，这个就是poorC所在位置
cout << hex << "-----------------------" << endl;
int* ptt = (int*)&(pms->x);
for (int i = 0; i < 15; ++i) {
cout << *(ptt + i) << endl;
}
//poorC的值被改为了0
cout << poorA << "," << poorB << "," << poorC << endl;
}
#pragma endregion
#pragma region 无题
const int* TestConstarr() {
int* iarr = new int[3]{ 1, 2, 3 };
return iarr;
}
template<int> //无意义的全特化,C#不支持
void TestAllConcreate() {
}
#pragma endregion
#pragma endregion
#pragma region 2018.8.4
#pragma region 静态函数重载
class CSox {
public:
static void f1(int x) {
cout << "f1 int" << endl;
}
static void f1(float x) {
cout << "f1 float" << endl;
}
};
#pragma endregion
#pragma region 有符号无符号赋值
void TestSignedUnsignedAssign() {
//1，vs2017c++默认允许进行数据截断，即double赋值给int可行
int ix = 2.3; //ok, 允许数据截断
cout << hex;
unsigned int ui = 0;
//2，有符号无符号混合运算
//计算过程：
//ui-1，转换为 ui + (-1)
//由于 -1默认为int, uint + int 类型自动转换为uint
//-1的补码为 0xffffffff，故 0 + 0xffffffff = 0xffffffff，对应无符号值还是0xffffffff
cout << ui - 1 << endl;//0xffffffff
//3，越界表现
int x = 65536; //2的16次方
int y = x * x; // 0, 原因：2的32次方是0x100000000，超出了32位，故截断为0
int y1 = (double)x*x*x*x; //0x80000000
int y2 = (double)(x*x); //0，原因：(x*x)这个单元在计算时是按int算的，自身算完后截断为0，再转double已经晚了
int y3 = double(x)*x;
double dx = double(x) * x;
int y4 = *(int*)&y3;
int z = pow(2, 32);//0x80000000， 原因同y1
int w = 2 ^ 3; //注意，这是异或，不是2的3次方
cout << hex<< y << "," << y1 << "," << y4 << "," << z << endl;
cout << "------------------------" << endl;
double a = 0x13edf000000011;
cout << "flaot a " << a << dec << "," << 0x01ffffff << endl;
unsigned int i = a;
//printf("a = %lx\n", a);
cout << hex<< "i=" << i << endl;
cout << dec << 0x33333333 << endl;
}
void testcasttype() {
int i = 0xffffffff; //-1
int j = 0xfffffffe; //-2
cout << "i=" << i << endl;
double di = i;
cout << di << endl;
auto typ1 = 0x8000; //int
auto typ2 = 0x7fffffff; //int
auto typ3 = 0x80000000; //unsigned int
auto typ4 = 0xffffffff; //unsigned int
auto typ5 = 0x100000000; //long long
//注意，=号右边表达式中的数据类型与=号左边的类型无关，如下计算等价于
//double = uint * int
double multype = 0x80000000 * 0x7fffffff;
//double 转int
//转换过程：double = uint * int
//=号右边是按最大类型uint 来算的
//uint 类型的0x80000000左移一位后出了uint范围，变为0
double td1 = 0x80000000 * 2;
//int转为double后，总能正确的转回来，前提：数据在int型数据范围内
//当一个数越出了int型表示范围，转换为int时，总会得到0x80000000
//1，double x = 0x2345e0f0d01f; (int)x ==> 0x80000000
//2，float x = 0x2345e0f0d01f; (int)x ==> 0x80000000
//当一个数越出了uint型表示范围，转换为uint时，得到被截断的低32位数据
//1，double x = 0x2345e0f0d01f; (int)x ==> e0f0d01f
//2，float x = 0x2345e0f0d01f; (int)x ==> e1000000
//注意，由于float的尾数只有23位可表示，因此截取数据会有误差，如上x只能精确到2345e0这24位，因此结果为e1000000
//虽然float的表示范围很大，但int转为float后再转回来就可能丢失数据
//即当int数据小于23位时，可以安全的转为float，然后再原样转回
int imax = 0x7fffffff;
cout << imax << endl;
cout << hex << (int)td1 << endl;
cout << hex << (unsigned int)td1 << endl;
float td2 = float(0x2345e0f0d01f);
cout << hex << (int)td2 << endl;
cout << hex << (unsigned int)td2 << endl;
cout << hex << (short)td2 << endl;
cout << hex << (unsigned short)td2 << endl;
cout << hex << (int)(char)td2 << endl;
cout << hex << (int)(unsigned char)td2 << endl;
int x = 65536;
int y3 = double(x)*x;
double y4 = double(x)*x;
//double y5 =
cout << *(int*)&y3 << endl;
}
void tstcast() {
int a = 0x60000000;
float *p = (float*)&a;
cout << *p << endl;
printf("%f\n", (float)(*p)); //0.000000
//printf("%f\n", (double(a)));//10.000000
}
#pragma endregion
#pragma region 数组和指针
void TestArrayAndPtr() {
short ac[] = { 1, 2, 4, 0, 3, 5, 7, 9 }; //数组
short* parr = new short[8] { 1, 2, 4, 0, 3, 5, 7, 9 };//指向数组的指针
//-----------------------------------------------------------------------------------
//数组比较特别，无法按照普通指针那样用 &p,p,*p的模式去通解它，只能分2种情况去理解，如下1，2
//-----------------------------------------------------------------------------------
//1，数组名指向数组首元素, 这与指向数组的指针表现一样
cout << *(ac) << endl;//1
cout << *(ac + 1) << endl; //2
cout << *(parr) << endl; //1
cout << *(parr+1) << endl;//2
//2，&数组名取得数组内存块的地址，而&指针取得指针的地址
cout << &ac << endl; //003CF830
cout << &ac + 1 << endl; //003CF840，内存偏移了16字节，即数组大小
cout << &parr << endl; //003CF824
cout << &parr + 1 << endl; //003CF828 //内存偏移了4个字节，任何指针大小都是4个字节
//3，数组指针，也叫行指针
short(*parr1)[8] = ∾ //指向具有8个short类型的数组
}
#pragma endregion
#pragma region const函数重载与常对象函数调用
class constoverload {
char _vals[10] = { 1, 2, 3, 4, 5, 6 };
public:
//利用const 进行函数重载
//1，如下 不算重载，算同一个函数，重定义会报错
//void f2(const float i){}
void f2(float i) {}
//2，利用const进行重载
void f1(const int i) const {
cout << "const f1" << endl;
}
void f1(int i) {
cout << "just f1" << endl;
}
//3，重载【运算符重载函数】
const char& operator[](int idx) const {//返回值是引用，必须加const修饰，否则违反了常函数规则
cout << "const operator[]" << endl;
return _vals[idx];
}
char& operator[](int idx) { //不是常函数，可以返回非const的引用
//注意，这里的返回值为引用，是为了使用 obj[idx] = 'x'操作，若非引用则不合法
cout << "operator[]" << endl;
return _vals[idx];
}
};
void Print(const constoverload& ctl) {
auto x = ctl[0]; //const operator[]
}
void TestConstOverload() {
//-----------------------------------------------------------------------
//常对象只能调用常函数，因为非常函数可能会更改了对象内的值
//-----------------------------------------------------------------------
const int ix = 10;
constoverload od;
const constoverload cod;
od.f1(1); //just f1
od.f1(ix); //just f1，注意这个调用，并不会因为参数是const int而去调用形参为const int的那个常函数
cod.f1(2); //const f1
//cod.f2(1); //error, 编译错误
od[0] = 'a'; //因为operator[]返回了引用，故可修改其返回值
//真实使用情形
Print(od);//const operator[]
//也可以这样
Print(cod);//const operator[]
}
#pragma endregion
#pragma endregion
#pragma region 2018.8.6
#pragma region 线程基本使用
void ThreadFunc(int t) {
this_thread::sleep_for(chrono::milliseconds(t));
//this_thread::yield();
//获取线程ID
cout << "thread started:" << this_thread::get_id() << "," << _threadid << endl;
}
void TestThread() {
std::thread t(ThreadFunc, 300);//可变参数
t.join();
//t.join();//1已经结束了，不可以再操作它，否则异常
std::thread t1(ThreadFunc, 1000);
//t1.detach(); //解除join，将当前线程作为后台线程，主线程结束后将报错
t1.join(); //再join会异常，已解除了不能再join
}
#pragma endregion
#pragma region 线程同步
int totalNum = 999;
std::mutex banklock;
void DrawbackMoney() {
banklock.lock();
if (totalNum < 0) return;
banklock.unlock();
if (totalNum < 0) {
throw std::exception("钱的数目小于0");//弹出框不显示此字符串？？？
}
for (int i = 0; i < 20; ++i) {
banklock.lock();
if (totalNum > 0) {
cout << "left: " << totalNum << ", thread:" << this_thread::get_id() << endl;
totalNum -= 10;
this_thread::sleep_for(chrono::milliseconds(100));
}
else {
banklock.unlock();
return;
}
banklock.unlock();
}
}
void TestThreadSync() {
thread t1(DrawbackMoney);
thread t2(DrawbackMoney);
thread t3(DrawbackMoney);
thread t4(DrawbackMoney);
thread t5(DrawbackMoney);
thread t6(DrawbackMoney);
thread t7(DrawbackMoney);
thread t8(DrawbackMoney);
thread t9(DrawbackMoney);
this_thread::sleep_for(chrono::seconds(3));
t1.join();
t2.join();
t3.join();
t4.join();
t5.join();
t6.join();
t7.join();
t8.join();
t9.join();
}
#pragma endregion
#pragma region 智能指针使用
class managedOjbect {
public:
float fx;
double dx;
managedOjbect() {
cout << "managed object constructor" << this << endl;
}
~managedOjbect() {
cout << "managed object destructor" << this << endl;
}
};
void TestShareptrUse() {
//1，多个智能指针间可以相互赋值，智能指针内部自动处理引用计算
std::shared_ptr<managedOjbect> ptr(new managedOjbect);
std::shared_ptr<managedOjbect> ptr1(ptr); //ok, ptr1与ptr引用同一个对象
ptr->fx = 10;
ptr1 = ptr;
ptr = ptr1;
std::shared_ptr<managedOjbect> ptr2(); //这是函数声明式，不是指针!!!
//2，不要将一个裸指针同时托管给多个智能指针，否则将发生重复析构
auto* pobj = new managedOjbect();
std::shared_ptr<managedOjbect> ptr3(pobj);
//std::shared_ptr<managedOjbect> ptr4(pobj); //析构异常，重复delete
auto* pobj1 = new managedOjbect();
auto* pobj2 = new managedOjbect();
std::shared_ptr<managedOjbect> ptr5(pobj1);
//3，尽量不要使用reset，因为它会释放托管对象，会导致其它智能指针异常
ptr5.reset(); //立即释放托管堆，即delete pobj1
ptr5.reset(new managedOjbect()); //立即释放原来的，持有新的对象
//4，智能指针不能用于数组
//std::shared_ptr<managedOjbect> arrptr(new managedOjbect[10]); //析构时异常，原因见下面异常分析
//std::shared_ptr<int> iarptr(new int[10]); //
//-----------------------------------------------------------------------------------
//析构异常分析：
//释放数组时应使用 delete[]，不应该使用delete
//-----------------------------------------------------------------------------------
//1，对于基本类型测试 delete与delete[]等价
int* pia = new int[10];
int* piab = pia; //&(pia[0]);
for (int i = 0; i < 10; ++i)
pia[i] = i;
delete pia; //&(pia[0]); //运行时不报错，数组内存被正确，完全释放
pia[1] = 0xff; //运行时出错，因为指针已是野指针了
piab[1] = 0xff; //正确运行
for (int i = 0; i < 10; ++i)//查看内存
cout << hex << piab[i] << ",";
cout << endl;
//2，对于自定义类型，应使用delete[]
//智能指针只处理单个类对象，而不处理数组，因此托管数组时析构异常，就是因为调用了delete而不是delete[]
auto* pobjs = new managedOjbect[10];
delete pobjs; //运行时崩溃，不是一个有效的堆指针，应使用delete[] pobjs;
}
#pragma endregion
#pragma region 自已实现智能指针
template<typename T>
class SmartPtrl {
std::size_t* psz = nullptr;
T* _ptar = nullptr;
public:
string name;
SmartPtrl(T* p) {
//带裸指针的构造函数只能是初始构造者，不能将同一个裸指针传递给两个不同的智能指针
//因为裸指针不知道如何去减少引用计数
psz = new std::size_t;
*psz = 1;
_ptar = p;
}
SmartPtrl(SmartPtrl& ptr) {
operator=(ptr);
}
SmartPtrl& operator=(SmartPtrl& ptr) {
if (this == &ptr || _ptar == ptr.get())
return *this;
if (_ptar) {
decrease();
}
_ptar = ptr.get();
psz = ptr.psz;
++(*ptr.psz);
}
T* operator->() {
return _ptar;
}
T& operator*() {
return *_ptar;
}
~SmartPtrl() {
cout << "destructor: " << name << endl;
if (_ptar)
decrease();
}
T* get() {
return _ptar;
}
void decrease() {
if (nullptr == psz)return;
(*psz)--;
if (*psz == 0)
{
delete _ptar;
delete psz;
_ptar = nullptr;
psz = nullptr;
}
}
};
void TestMySmartPtr() {
SmartPtrl<managedOjbect> ptr(new managedOjbect);
ptr.name = "ptr";
SmartPtrl<managedOjbect> ptr2(ptr);
ptr2.name = "ptr2";
//自赋值及相等指针赋值测试
ptr2 = ptr;
ptr = ptr2;
ptr = ptr;
SmartPtrl<managedOjbect> ptr3(new managedOjbect);
ptr3.name = "ptr3";
SmartPtrl<managedOjbect> ptr4(new managedOjbect);
ptr4.name = "ptr4";
ptr3 = ptr4;
//重载的指针运算符使用起来有点奇怪，如下两种等价
//按常理，operator->应该返回一个引用而不是指针
ptr3->dx = 30; //从这个来看，->返回的应该是一个引用
ptr3.operator->()->dx = 30; //这才是它的本质
cout << ptr4->dx << endl;
cout << (*ptr4).dx << endl; //operator*
}
#pragma endregion
#pragma region delete和delete[]的表现
void testDeleteStack() {
//1，测试1
managedOjbect* pobj = new managedOjbect();
//delete[] pobj; //不报错，运行时不断析构
//2，测试2
managedOjbect* pt = &(pobj[100]);
//delete pt; //不报错，运行无错
//delete[] pt; //不报错，运行时不断析构
//3，测试3
managedOjbect mobj;
//delete[] & mobj; //不报错，运行时不断析构
//4，测试4
managedOjbect* pobjs = new managedOjbect[3];
//delete pobjs; //运行时异常
//5,查看内存头，数据似乎也正常
CHeapDebugger<managedOjbect, 1>::Print(pobj);
//总结：
//对于基本类型，使用 delete[]万无一失
//对于类对象类型，单对象使用delete，数组对象使用delete[]，否则出错
//对单对象使用delete[]，将出现上面的死循环析构
//对数组对象使用delete，将抛出运行时异常
}
#pragma endregion
#pragma region 模板特化
//------------------------------------------------------------------------------------------
//模板特化的起因是：某些特定类型不适用于模板的通用算法，需要特化出一个专用版本来处理它（写个特定算法）
//同时，由于模板不支持定义类名相同而类型个数不同的模板
//对于模板类型参数个数可变的需求，C++11提供了typename...语法支持可变类型参数
//------------------------------------------------------------------------------------------
//1，模板特化是指在原始模板的基础上，特化出一个同名的模板来，只是参数被特化了
//注意模板特化的语法是在类名后加<>并指定特化类型
template<typename T, typename T2>
class tehuaTemp {//原始版本
public:
T Max(T a, T b) {
cout << "max a b" << endl;
return a > b ? a : b;
}
};
//2，只能定义一个模板原始版本，不能通过增加或减少模板类型参数个数来定义不同的同名模板
// template<typename T, typename T2, typename T3> //不能这样做，
// class tehuaTemp{
// public:
// T Max(T a, T b) {
// cout << "max a b" << endl;
// return a > b ? a : b;
// }
// };
//3，这不是模板特化
// template<typename T, typename T2, typename T3>
// class tehuaTemp<T, T2, T3> {//原始版本
// public:
// T Max(T a, T b) {
// cout << "max a b" << endl;
// return a > b ? a : b;
// }
// };
template<typename T>//偏特化
class tehuaTemp<T*, int*> {//特化出一个T*版本，语法：类名<类型...>，区别于模板类的定义
public:
T Max(T* a, T* b) {
cout << "max *a *b" << endl;
return *a > *b ? *a : *b;
}
};
template<> //全特化
class tehuaTemp<string, int> {//特化出一个字符串版本
public:
int Max(string a, string b) {//字符串特化版本的Max
cout << "stricmp" << endl;
return _stricmp(a.c_str(), b.c_str());
}
};
//4，模板特化类似于特化继承，正因如此，二者不能同时存在
//如下，CTX1与tehuaTemp<int>等价，不能同时存在
class CTX1 : public tehuaTemp<int, string> {
};
//5，类型参数个数可变的模板
template<typename t1, typename... others>
void xprintx(t1 fst, others... ors) {
cout << fst << endl;
xprintx(ors...);
}
void TestVarTemplatex() {
xprintx(1, 2, "hello", 4, 5, "world");
}
// template<>
// class tehuaTemp<int> {
//
// };
void TestTehuaTemp2() {
tehuaTemp<float, int> tht;
tht.Max(3, 4); //max a b
float a = 1, b = 2;
//tht.Max(&a, &b);
//注意下面的调用
//1，没有特化版本时也可以正常调用，此时用T=float*调用原始版本
//2，有特化版本时，调用指针版本，此时类型参数为 T=float
tehuaTemp<float*, int*> thit;
thit.Max(&a, &b); //max *a *b
//指针特化版本的实际使用是字符串比较
char* ps1 = "hello";
char* ps2 = "world";
tehuaTemp<char*, float*> scmp;
scmp.Max(ps1, ps2);//max a b
//另一个字符串比较的特化版本
tehuaTemp<string, int*> td;
cout << td.Max("1", "efg") << endl; //使用字符串特化版本的Max
}
#pragma endregion
#pragma endregion
#pragma region 2018.8.7
#pragma region 变量初始化及顺序
class CtestInitobj {
public:
CtestInitobj(float fx) {
cout << "CtestInitobj-cons" << endl;
}
CtestInitobj() {
cout << "CtestInitobj-default-cons" << endl;
}
};
class DefaultConstrutor {
class inclass {
public:
inclass(string s) {
cout << "inclass-cons" << endl;
}
};
public:
int fx; //1，基本类型成员默认没有初始化
static int ix; //2，静态的数据必须在类外定义一次，就算是int也不例外
inclass oic; //3，变量初始化顺序与声明顺序相同
CtestInitobj oti;
public:
DefaultConstrutor(float fx, string str):oic(str) {
cout << "fx: " << hex << *(int*)&this->fx << endl; //cccccccc，未初始化
cout << "default constructor" << endl;
//4，对成员对象的初始化最好是放在初始化列表中，因为放在这里赋值，会有两次构造函数被调用：
//(1)，其默认构造函数，(2)，有参构造函数
oti = CtestInitobj(1);
}
};
int DefaultConstrutor::ix; //全局对象不写初始值默认为0;
void testInitorders() {
DefaultConstrutor od(1, "a");
}
#pragma endregion
#pragma region sealed与final及override
//sealed 与 final本质上是一样的，MSDN：在标准类上使用final,在ref类上使用sealed
//大概可理解为c++中使用final，c#中使用sealed
//但实际情形是C++中可以使用final或sealed或同时混合使用，C#中只认sealed
class Csealfinal /*final sealed*/ {//1，修饰类时，可以一起使用，或单个使用，该类不能被继承
public:
virtual void out() /*final sealed*/ {//2，修饰虚函数时，可以一起使用，或单个使用，该函数不能被override
cout << "virtual-out-func" << endl;
}
void funx() /*final*/ {//3，不能修饰非虚函数
}
};
class dcsealfinal sealed //4，注意这个sealed的写法位置
: public Csealfinal {
private:
void out() override sealed {
cout << "deriseal-out-" << endl;
}
};
#pragma endregion
#pragma region 在类外调用私有函数
class CallPrivateVirtualFunc /*final sealed*/ {//修饰类时，可以一起使用，或单个使用，该类不能被继承
public:
virtual void out() {
cout << "virtual-out-func" << endl;
}
};
class Dcallprivate : public CallPrivateVirtualFunc {
private:
void out() {//注意，这是个私有的重写虚函数,它也能实现多态调用
cout << "deriseal-out-" << endl;
}
};
void testCallPrivateFuncOutside() {
Dcallprivate osa;
CallPrivateVirtualFunc* psa = new Dcallprivate();
//利用虚函数调用机制，可以在类外调用私有函数
psa->out(); //调用私有的函数
}
#pragma endregion
#pragma region 静态类
static class CStaticClass {
public:
CStaticClass() {
cout << "cstaticclass-constructor" << endl;
}
static int fx;
string name = "static class";
};
int CStaticClass::fx; //默认为0
void Teststaticclass(){
//从以下测试看来，C++中的静态类与普通类没有任何区别
CStaticClass os;
os.name = "os";
auto* pcs = new CStaticClass();
cout << pcs->name << ", " << pcs->fx << endl;
cout << CStaticClass::fx << endl;
}
#pragma endregion
#pragma region mutable变量在const函数中的使用
class cConstclassMutable {
float fx;
mutable float fy;
public:
void Print() const {
fy = 10; //ok
//fx = 10; //error
}
};
#pragma endregion
#pragma region const&返回值并不绝对安全
class CConstRefcls {
char str[10] = "hello";
public:
const char& getStr(int idx) {
return str[idx];
}
char& getStrc(int idx) const {
}
void out() {
cout << str << endl;
}
};
void TestModifyCOnstref(){
CConstRefcls ocr;
char* pc = (char*) &(ocr.getStr(0));
*(pc) = 'x';
ocr.out();
}
#pragma endregion
#pragma region 跨编译单元的初始化问题
//游戏引擎设计中，需要一个gGame的全局对象来供所有地方方便的使用
//【有问题的设计】会有跨编译单元的初始化顺序问题
//game.h，实现如下，使用者可能在game.cpp编译前已经要使用gGame了，这时候将报错
// class CGame {
// };
// extern CGame gGame;
//game.cpp中实现定义
//CGame gGame;
//【正确的设计】
CGame& theWorld() {//在使用前总能保证实例对象已初始化，且不用便不初始化
static CGame sgame; //利用了局部静态变量的性质：只会在初次使用时定义一次，且一直存在
return sgame;
}
void testSingleton() {
gGame.InitGame();//使用，没问题
//但这个设计存在一个问题，如何保证gGame在所有使用者使用前已初始化完成？
//在跨编译单元时，这种顺序是无法保证的，因此，引出了另一种设计：
theWorld().InitGame();
}
#pragma endregion 利用local static实现单例
#pragma region 一个空类有什么
//当你写出一个空时，编译器会为它生成：
//public inline的默认构造函数
//public inline的拷贝构造函数
//public inline的析构函数
//public inline的operator=
//class CEmpty{}; //空类
class CEmpty {//编译器生成的类，但这些东西，只有在被需要时才产生
public:
CEmpty(){}
CEmpty(const CEmpty& rhs){}
~CEmpty(){} //若基类是虚析构函数，则编译器在这里也会生成一个默认的虚析构函数
CEmpty& operator=(const CEmpty& rhs) { return *this; }
};
void TestCompilerClass() {
CEmpty od; //生成默认构造函数，析构函数
CEmpty od1(od); //copy constructor
od1 = od; //operator=
}
#pragma endregion
#pragma region 阻止类对象被拷贝
//方法一： 将拷贝构造函数与operator=声明为private且不实现，错误只能在链接期间被发现【见effective C++】
//实际上，对于这种情况，现代编译器也能在编译期直接发现错误，测试版本[VS2017]
class CUncopyableCls {
public:
CUncopyableCls(){}
~CUncopyableCls() {}
private:
CUncopyableCls(const CUncopyableCls& rhs);
CUncopyableCls operator=(const CUncopyableCls& rhs);
};
//方法二，生成一个基类,将拷贝构造函数与operator=声明为private且不实现
//同时，生成一个子类，不写拷贝构造函数和operator=
//这样，编译器在编译时就会尝试为子类生成二者
class CUncopyable {
protected://使可以继承
CUncopyable() {}
~CUncopyable() {}
private:
CUncopyable(const CUncopyableCls& rhs);
CUncopyable operator=(const CUncopyable& rhs);
float fx;
};
class CUncopyableClass : public CUncopyable {//不实现拷贝构造函数和operator=
};
void testUncopyableobj() {
CUncopyableCls ou1, ou2;
//ou1 = ou2; //编译错
CUncopyableClass oup, oup1;
//oup = oup1;//编译错：编译器发现有operator=需求，尝试为CUncopyableClass生成operator=
//并调用基类operator=，但由于它为私有的，不能调用，因此，编译出错
}
#pragma endregion
#pragma region 抽象类及虚析构
//1，当声明一个虚析构时，意味着类为基类
//2，继承别人的类时，要注意它有没有虚析构，如标准库函数string
class CMystr : public string {//string类并没有虚析构函数，这样做将有内存泄漏的风险
};
class CMyVec : public std::vector<int> {//vector也没有
};
void testVirtualMemLeak() {
string* pstr = new CMystr();
delete pstr; //内存泄漏
CMystr mstr;
}
//3，使用纯虚析构函数实现抽象基类的trick
class CMyxxxAbastractcls {
float fx;
string name;
public:
void instFunc(){}
virtual ~CMyxxxAbastractcls() = 0; //这样就声明了一个纯虚析构函数，有纯虚函数的类便是抽象类，不能被实例化
};
//4，但必须实现它，否则链接报错: 因为析构子类对象时最终要调用基类析构函数
//抽象类也需要被析构，因为抽象类并不像C#的接口，抽象类中有成员数据需要释放
CMyxxxAbastractcls::~CMyxxxAbastractcls(){
cout << "pure virtual function " << endl;
}
class CDxxObj : public CMyxxxAbastractcls {
public:
CDxxObj() {}
~CDxxObj() {}
};
void testpurevirtualfunc() {
CMyxxxAbastractcls* pyx = new CDxxObj();
delete pyx; //pure virtual function
}
#pragma endregion
#pragma endregion
#pragma region 2018.8.8
#pragma region 结构体&联合体&字节对齐&大小端
void testEndian() {
//1, 联合体使用测试
union {//1.1，C风格定义并初始化
char ch;
char ch1;
long l;
} un = { 1 };
union ux {//1.2，C++风格定义
char ch[4];
long l;
ux(){}
ux(long l) {//可以有构造函数
this->l = l;
}
void fx() {//可以有函数，默认公有，同结构体
cout << "union func: " << endl;
cout << ch[0] << endl;
}
};
//1.3 联合体不管字节对齐，只取成员中最大的尺寸
union UN //size = 1
{
char ch;
char ch1;
char ch2;
};
union UN1 //size = 3
{
char ch[3];
};
union UN2 //size = 4
{
char ch;
int it;
};
//2，结构体字节对齐
#pragma pack(push, 4)//总是按4的整数倍分配内存，宁多不少
struct ST {
char ch; //4
double d; //8
char ch1; //4
char ch2;
short srt;
int ix;//4
char ch3;//4
};
#pragma pack(pop) //恢复原来对齐
cout << sizeof(ST) << endl;
//3，大小端模式
//常用机型均为小端模式：
//(1) X86系统架构 (2) arm系列：IOS,android等，默认为小端模式，可设置为大端
//3.1 使用联合体测试机型大小端
union { char ch[4]; long l; } uni = { 0x64636261 };
cout << (uni.ch[0] == 0x61 ? "小端" : "大端") << endl;
}
#pragma endregion
#pragma region 旧式转换的隐患
class cax {
public:
float fax = 1;
};
class cbx : public cax {
public:
float fbx = 2;
};
class ccx {
public:
float fcx = 3;
};
void testForceCasttype() {
cax* pax = new cbx();
cax* pa = new cax();
//旧式转型在类对象中无安全保证
cbx* pbx = (cbx*)pax;
cbx* pb = (cbx*)pa; //不是子类型，运行时不报错，直到通过pb指向内部成员
ccx* pcx = (ccx*)pax; //没有继承关系编译器不报错，因为任何指针间都可以强转
cout << pb->fax << endl; //1，输出的是fax
cout << pb->fbx << endl; //不确定值，因为pb并不是一个cbx类型
cout << pcx->fcx << endl; //1，输出的是fax的值
}
#pragma endregion
#pragma region STL-VECTOR
void testvector() {
vector<int> vec{ 1, 2, 3 };
vector<string> vecStrs(1);
vecStrs.emplace_back("hello");
cout << vecStrs.size() <<", " << vecStrs.capacity() << endl;
}
#pragma endregion
#pragma region 2018.8.14
#pragma region int型数值边界
void testIntLimit() {
//C++中不允许使用-2147483648这个值，因为它把符号与数值当成两部分来看了
//首先把2147483648看成uint32，再加上前面的负号时，编译器报错：一元负运算符应用于无符号类型，结果仍为无符号类型
//int32的表示范围是 -2147483648 ~ 2147483647，C++不让用，有点奇怪，C#是可以的
//因上在C++中，只能这样用：
int ix = -2147483647 - 1; //系统宏INT_MIN 就是这样定义出来的
cout << ix - 1 << endl; //0x80000000 + 0xffffffff = 0x7fffffff
//C#中可以这样用
//int ix = -2147483648; //ok，2147483648被看作uint32
//WriteLine(ix - 1); //0x80000000 + 0xffffffff = 0x7fffffff
}
#pragma endregion
#pragma region 汇编测试
void testASM() {
int i = 10;
int j = 20;
int bp = 0;
_asm {
mov dword ptr[i], 10h
//mov dword ptr[bp], 10h //编译出错，变量bp与寄存器同名，被认为是16位的bp寄存器
mov dword ptr[j], edi
lea eax, [ebp]
mov DWORD ptr[j], eax
}
cout << i << "," << j << endl;
}
#pragma endregion
#pragma endregion
#pragma endregion
void xprintx() {
}
int _tmain(int argc, _TCHAR* argv[])
{
//TestVarTemplatex();
TestTehuaTemp2();
//testInitorders();
//testASM();
//testIntLimit();
//testvector();
//testForceCasttype();
//testEndian();
//testpurevirtualfunc();
//testVirtualMemLeak();
//testSingleton();
//TestModifyCOnstref();
//testInitorders();
//testCallPrivateFuncOutside();
//Teststaticclass();
//TestTehuaTemp2();
//testDeleteStack();
//TestMySmartPtr();
//TestShareptrUse();
//TestThreadSync();
//TestThread();
//TestConstOverload();
//testcasttype();
//TestArrayAndPtr();
//TestSignedUnsignedAssign();
//TestPointerType();
//TestMemLayout();
//Test4Typecast();
//TestOddConstructor();
//TestXiebian();
//a = b;
//EffectiveCpp::Test02();
//TestStlSortFunc();
//Dijkastra();
//TestPointerType();
//TestSameTypeAssign();
//TestRef();
//TestTehuaTemp();
//TestCComplexOper();
//TestTypecastOper();
//TestTypecastContructor();
//TestNestingFuncPtrs();
//TestArrayAndPointer();
///TestRealloc();
//TestComputeDataStorage();
//TestVirtualFunctionTable();
//TestAdd2Num();
//TestAstrPstr();
//TestCWithStatic();
//TestThread();
//TestVarTemplate();
return 0;
}
