auto与decltye的区别
//typeid只能获取类型 不能获取 引用 常量
//auto无法区分常量变量 也无法区分引用变量
//decltype 可以获取常量属性，引用属性
//auto不可以放在结构体内部
#include<vector>
void maiz1()
{
const vector<int>myint{1,2,3,4,5};
auto inta = myint[1];
cout << typeid(inta).name() << endl;
decltype(myint[1]) intd = myint[1];
cout << typeid(intd).name() << endl;
cin.get();
}
type_traits
#include<type_traits>
template<class T1,class T2>
void same(const T1 &t1,const T2&t2)
{
cout << typeid(T1).name() << is_integral<T1>::value << endl;
cout << is_same<T1, T2>::value << endl;
//判断模板的数据类型
}
//typename enable_if< is_same<T1,T2>::vlaue >::type *p =nullptr 默认参数
//typename enable_if< is_same<T1, T2>::vlaue >::type
// enable_if< is_same<T1, T2>::vlaue >::type
template<typename T1,typename T2>
void check_type1(const T1 &t1, const T2 &t2,
typename enable_if< is_same<T1,T2>::vlaue >::type *p =nullptr)
{
cout << " " << t1 << " " << t2 << endl;
cout << "类型相同" << endl;
}
template<typename T1,typename T2>
void check_type1(const T1 &t1, const T2 &t2,
typename enable_if<!is_same<T1, T2>::vlaue >::type *p = nullptr)
{
cout << " " << t1 << " " << t2 << endl;
cout << "类型不相同" << endl;
}
void mainz2()
{
int i(10);
int &ri(i);
int &&rri(i + 3);
cout << is_lvalue_reference<decltype(i)>::value << endl;
cout << is_lvalue_reference<decltype(ri)>::value << endl;
cout << is_rvalue_reference<decltype(ri)>::value << endl;
//判断是左值引用还是右值引用
//is_rvalue_reference<decltype(ri)>::value
int a[5];
int*p = a;
cout << is_array<decltype(a)>::value << endl; //判断是不是数组
cout << is_array<decltype(p)>::value << endl;
int num = 20;
double db = 20;
string str1;
cout << is_integral<decltype(num)>::value << endl;
cout << is_integral<decltype(db)>::value << endl;
cout << is_class<string>::value << endl;
cout << is_class<decltype(str1)>::value << endl;
//判断数据类型
same(11, 22);
same(11.1, 22);
same(3, "123");
check_type1(10, 10);
check_type1(1, 10.1);
cin.get();
}
枚举体
//C语言枚举 本质类型检测不严格 允许类型不一致
//C语言枚举 本质类型检测不严格 允许类型不一致
enum color {
red,
yellow,
white,
blue
};
//没有赋值 默认0-递增 赋值从赋值开始递增
//指定数据类型 枚举名称不可以重名 外部不可以 内部不可以
enum coloros :char
{
red1,
yellow1,
white1,
blue1
};
enum class colorX:unsigned long
{
red2,
yellow2,
white2,
blue2
};
enum class jun :int
{
司令=10,
军长=9,
师长
};
void mainz3()
{
enum color color1(red);
enum color color2(color::white);//初始化一般形式
//color1 = 1; //C++不可以 类型检测严格
colorX c1(colorX::red2);// 遵循严格
cin.get();
}
占位参数
//预留参数接口 参数无法调用
void add(int a,int b,int) //C++允许有占位：
{
}
template<class T>
void show(T a, T, T c) //预留接口 第二个参数无法调用
{
}
void mainz4()
{
add(1, 2, 3);
cin.get();
}
寄存器变量
void mainz5()
{
register int num = 10;// register 对于CPP来说 只是建议
cout << &num << endl; //CPP自动优化到内存 编译器优化 检测到取地址 就会优化为内存变量
//&num //C语言无法取寄存器地址
cin.get();
}
CPP左值右值自动转换
void mainz6()
{
//C++ 会把有内存实体的右值转换为左值
int i(3);
(++i) = 13;
(i = 2) = 6;
cout << i << endl;
cin.get();
}
共用体
//节约内存
//CPP共用体 可以初始化 内部可以有函数
//共用体 共享内存 不计入代码区大小
//union 默认是公有 可以设置为私有
//可以实现封装 只有一个变量
//共用体无法继承 多态
union MyUnion
{
int num;
double data;
void go()
{
cout << "dd" << endl;
}
};
void mainz7()
{
MyUnion my1{ 14 }; //只能初始化一个变量
cout << my1.num << endl;
my1.data = 10.55;
cout << my1.num << endl;
cin.get();
}
硬盘模式查询文件流
#include<fstream>
#include<memory>
#include<string>
#include<cstring>
#include<cstdlib>
//C++文件 ifstream ofstream
//cin cout fin fout >> <<适用于屏幕 文件
//string
void mainz8()
{
ifstream fin("E:\\New\\视频\\智峰互联\\资料\\大数据相关数据\\kaifang.txt");
ofstream fout(R"(C:\res.txt)");
if (!fin || !fout)
{
cout << "文件打开失败" << endl;
return;
}
//char name[300]{ 0 };
string name;
cin >> name;
while (!fin.eof()) //没有到文件末尾 就继续
{
//char str[500]{ 0 };
//fin.getline(str,500); //读取一行
//char*p = strstr(str, name);
string str;
int pos = str.find_first_of(name);
//.find_first找到第一个相同的字符 find查找整体
//fin.getline(const_cast<char*>(str.c_str()) , 500);
if (pos != -1)
{
cout << str << endl;
fout << str << endl; //打印到屏幕 写入到文件
}
}
fin.close();
fout.close(); //关闭文件
system(R"(C:\res.txt)");
cin.get();
}
内存模式查询文件流
#include<vector>
#include<fstream> //文件流
#include<memory>
vector<string> g_all; //动态数组 每一个元素都是字符串
int i = 0;
//效率低 因为STL有很多优化
void loadmem()
{
ifstream fin("E:\\New\\视频\\智峰互联\\资料\\大数据相关数据\\kaifang.txt");
if (!fin )
{
cout << "文件打开失败" << endl;
return;
}
while (!fin.eof()) //没有到文件末尾 就继续
{
char str[500]{ 0 };
fin.getline(str, 500);//读取一行
string putstr;
putstr += str; //生成C++字符串
g_all.push_back(putstr); //压入
if (i++ > 10000)
{
break;
}
}
fin.close();
}
void search()
{
while (1)
{
string str;
cin >> str;
for (auto i : g_all)
{
int pos = i.find(str,0); //查找
if (pos != -1)
{
cout << i << endl;
}
}
}
}
void mainz9()
{
loadmem();
search();
cin.get();
}
CPP结构体
//1 C++结构体可以为空 C不可以
//2 C++结构体可以有默认值 C不可以
//3 C++结构体定义变量无需关键字struct
//4 C++结构体可以有函数
//5 变量是函数指针 是变量 是lamba函数块 不计入体积
//6 结构体默认公有 可以设置为私有
//7 没有私有变量情况下初始化方法
________//point p1{ 1,2 };
________ //point *p = new point{ 1,2 };
________ //point px[2] = { { 1,2 },{ 3,4 } };
________ //point *pj = new point[2]{ { 1,2 },{ 3,4 } };
________ //8 私有 需要构造函数 按照这个风格初始化
________ //pointit p11(1, 2);
________ //pointit *p11 = new pointit(3, 4); //指针
________ //pointit pss[3]{ pointit(3, 4) ,pointit(8, 4) ,pointit(5, 4) }; //数组
________ //pointit *pas = new pointit[3]{ pointit(3, 4) ,pointit(8, 4) ,pointit(5, 4) };//堆_________上数组
//9 结构体的声明 只能创建指针或者引用 扩展结构体作用范围
//10 结构体内部可以创建引用或者指针
//11 匿名结构体 不可以初始化
//12 结构体之间直接赋值 浅拷贝 只是赋值值 一般数据 指针（不复制指向的地址）
//13 赋值 无论私有还是公有都能拷贝
struct mystructX
{
int num = 3;
function<void(void)> fun = []() {};
//auto fu //结构体无法保存auto
};
struct mystructXX
{
void(*p)() = []() {}; //指针4字节
function<void(void)> fun = []() {}; //40字节
function<void(int)> fun1 = [](int a) {};
function<void(char*)> fun2 = [](char*str) {};
};
struct pointl; //结构体的声明 只能创建指针或者引用
struct point
{
int x;
int y;
struct point*p;
struct point& rp; //结构体内部可以创建引用或者指针
};
struct pointit
{
public:
pointit(int a,int b):x(a),y(b)
{
}
private:
int x;
int y;
};
struct wu
{
virtual void show()
{
cout << "老子" << endl;
}
};
struct xiaowu:public wu
{
void show()
{
cout << "小子是大爷" << endl;
}
};
void mainz10()
{
//fun 包装器 一个40个字节
//cout << sizeof(mystructXX) << endl;
point p1{1,2};
point *p = new point{ 1,2 };
point px[2] = { {1,2},{3,4} };
point *pj = new point[2]{ { 1,2 },{ 3,4 } };
pointit p11(1, 2);
pointit *p11 = new pointit(3, 4); //指针
pointit pss[3]{ pointit(3, 4) ,pointit(8, 4) ,pointit(5, 4) }; //数组
pointit *pas=new pointit[3]{ pointit(3, 4) ,pointit(8, 4) ,pointit(5, 4) };//堆上数组
p1.x = p1.y = 20;
wu*pw = new wu; //多态
pw->show();
pw = new xiaowu;
pw->show();
cin.get();
}
异常
//异常与错误不一样 异常 一般能够正常工作
//错误就是程序无法正常工作 无法编译
//异常让程序在错误的输入 文件不存在 内存异常的情况下仍然可以正常工作
//try throw catch
int divvv(int a, int b)
{
try //尝试
{
if (b == 0)
{
throw 1; //抛出异常 跳到catch
}
cout << a << " " << endl;
return a / b;
}
catch (int code) //捕获错误
{
if (code == 1)
{
cout << "被除数不可以为0" << endl;
}
return 0;
}
}
void mainz11()
{
int a, b;
cin >> a >> b;
divvv(a, b);
cin.get();
}
CPP数据类型极限
#include<limits>
void mainz12()
{
//cout << numeric_limits<int>::max() << endl;
//cout << numeric_limits<int>::min() << endl;
cout << numeric_limits<int>::lowest() << endl; //最小 整数含义一样
//cout << numeric_limits<double>::min() << endl; // 对于double 能表示最小精度的数
//cout << numeric_limits<double>::lowest() << endl; //能表示最小的数
cin.get();
}
算法容器函数
#include<functional>
#include<numeric>
#include<vector>
#include<algorithm>
using namespace std::placeholders;
template<class T>
bool getT(T data)
{
return data % 2 == 0;
}
int get(int num)
{
return num % 2 == 0;
}
struct myx
{
int get(int num)
{
return num % 2 == 0;
}
};
struct XXXX
{
int operator()(int num)
{
return num % 2 == 0;
}
};
void mainz13()
{
vector<int> myint{1,2,3,4,5,6,7,8,9,10};
//计数满足_Pred（第三个参数）的元素
int num = count_if(myint.begin(), myint.end(), [](int data) ->bool {return data % 2 == 0;});
int num1 = count_if(myint.begin(), myint.end(),XXXX());
XXXX x1;
int num2 = count_if(myint.begin(), myint.end(), x1);
int num3 = count_if(myint.begin(), myint.end(), get);
int num4 = count_if(myint.begin(), myint.end(), get);
myx my1;
auto fun = bind(&myx::get,&my1,_1);
int num5 = count_if(myint.begin(), myint.end(), fun);
int num6 = count_if(myint.begin(), myint.end(),getT<int>);
cout << num << endl;
cout << num1 << endl;
cin.get();
}
匿名对象与分配内存时手动控制构造与析构
#include<memory>
#include<allocators>
#include<cstdlib>
class mycalssx
{
public:
mycalssx()
{
cout << "mycalssx()" << endl;
}
mycalssx(const mycalssx&my) //拷贝构造函数
{
cout <<"const mycalssx()" << endl;
}
//mycalssx()
//{
// cout << "mycalssx()" << endl;
//}
private:
};
void mainz14()
{
mycalssx*p = new mycalssx;
allocator<mycalssx>my; //分配器 可以自动控制构造 和 析构的时间
mycalssx*px = my.allocate(1);//分配一个元素
my.construct(px,mycalssx()); //调用构造函数 //mycalssx() 匿名对象 销毁
my.destroy(px);//释放内存 调用析构
my.deallocate(px,1); //直接释放
mycalssx*px3 = my.allocate(3);//分配3个元素
my.construct(px3, mycalssx());
my.construct(px3+1,mycalssx());
my.construct(px3+2, mycalssx());
my.destroy(px3);//释放内存 调用析构
my.destroy(px3+1);//释放内存 调用析构
my.destroy(px3+2);//释放内存 调用析构
////匿名对象寄存器缓存
//mycalssx(); //匿名对象 构造完了 不保存 马上析构
//mycalssx*p = new mycalssx(); //保存在堆上 就不在析构
//mycalssx f1 = mycalssx(); //创建对象
int a(5); //原理就是构造函数 ==== int a=int(5);
cin.get();
}
类默认生成的四个函数
//类默认生成4个函数： 拷贝构造 构造 析构 赋值重载
//myclass520 my1; myclass520 my2(my1); //拷贝构造
//myclass520 *p=new myclass520; //构造
//delete p; //析构
//my1=my2; //赋值重载
//delete删除
//default存在
//C++会给每个类生成四个函数 写了新函数会覆盖 default存在
class myclass520
{
public:
//mycalss520(const myclass520&my) = delete;
//myclass520() = delete;
//void operator=(const myclass520&my)=default;
//myclass520() =default; //default 存在 声明一下
int x;
int y;
myclass520()
{
cout << "creat" << endl;
}
~myclass520()
{
cout << "delete" << endl;
}
myclass520(const myclass520 &my)
{
x = my.x;
y = my.y;
cout << "拷贝构造" << endl;
}
//myclass520 operator=(const myclass520 &my)
void operator=(const myclass520 &my)
{
x = my.x;
y = my.y;
cout << "赋值重载" << endl;
}
void show()
{
cout << x << " " << y << endl;
}
private:
};
class bobo
{
public:
int x;
int y;
int z;
//写了构造函数 往往会覆盖原生
bobo() = default;
bobo(int a,int b,int c):x(a),y(b),z(c)
{
}
~bobo()
{
}
private:
};
void mainr15()
{
//myclass520 my1; //调用构造函数
//myclass520 my2(my1);//调用拷贝构造
//myclass520 my3;
//my3 = my1; //调用赋值重载
myclass520 my1;
my1.x = 10;my1.y = 20;
my1.show();
myclass520 my2(my1);
my2.show();
cin.get();
}
模板参数展开
#include<cstdarg>
template<class T>
void showit(T t)
{
cout << t << endl;
}
template<class...Args>
void all(Args...args)
{
int arr[] = { (showit(args),0)... };
}
template<class...Args>
void allit(Args...args)
{
int arr[] = { (showit(args),0)... };
//int arr[] 约束展开 不能省略
}
void mainz16()
{
all(1, 2, 3, 4, 5,6);
allit(1, 'a', "ssss", 7.8);
cin.get();
}
转义字符
#include<string>
void main()
{
string str1(R"(12345\n455)");
string str2(R"-(12345\n455"""12345\n455)-"); //-处理对称性错误
cout << str1 << endl;
cout << str2 << endl;
cin.get();
}
