auto
//C++14自动推理返回值
//C++11 需要返回->指定类型
auto (*f)() -> int(*)();
//f是什么类型?
int(* (*fx)() )( ); //返回值是函数指针
auto pf(void) -> auto(*)(int x) -> int(*)(int a,int b)
{
//层级运转方式： 从左往右
return nullptr;
}
//pf是什么类型？
// auto pf(void) -> auto(*)(int x) -> int(*)(int a,int b)
// int (* (* pf(void) )(int x) )(int a,int b)
// int (__cdecl* (__cdecl* __cdecl(void) )(int) )(int,int)
void main()
{
cout << typeid(pf).name() << endl;
cin.get();
}
模板别名
template<class T> using t = T;
template<class T> using tp = T*;
template<class T>
T show(T t1)
{
t<T> tx(t1);
tp<T>tp1(&tx);
cout << tx << " " << tp1 << endl;
return tx;
}
#include<array>
//模板别名 用别名优化模板名称 只能放在类 命名空间 全局 不能放在函数内部
template<class T1> using t1 = array<T1,10>;
template<class T, int n> using wu = array<T, n>;
void main01()
{
using intarry = array<int, 10>; //模板别名 明确类型
double a=10;
// cout << show(a) << endl;
t1<int> t11{ 1,2,3,4,5,6,7,8,9,10 };
for each (auto i in t11)
{
cout << i << endl;
}
wu<int, 10> t12{ 1,2,3,4,5,6,7,8,9,10 };
for each (auto j in t12)
{
cout << j << endl;
}
cin.get();
}
收缩转换 constexpr inline
//收缩转换
void main02()
{
//char ch0(7777) ; // 不保证结果的正确
//char ch1{ 7777 };// 保证数据类型安全转换 越界编译错误
cin.get();
}
//C++14 二进制
void main03()
{
int a = 0b1001; //0b 0B代表二进制
cout << a << endl; //9
cin.get();
}
//constexpr 标识返回值或者其他表达式是常量
constexpr int get()
{
return 5;
}
//inline
namespace all
{
//inline 展开在all 默认的版本
inline namespace V2015
{
}
}
lambda表达式
初级
//lambda表达式： 解决函数怀孕现在
void main04()
{
//[] {cout << "ssssss" << endl;}(); //匿名表达式 （）最后一个括号 起调用
// { } 函数体 执行
auto fun = [] {cout << "sssss" << endl;}; //返回函数指针
fun(); //调用
[]{ cout << "xxxxxxx" << endl,cout << "ddddd" << endl; }();
//[]操作外部变量 ()参数列表 {}函数体 ()调用
[] (char*str){cout << str << endl;}("kkkkk"); //匿名
auto fun1 = [](char*str) {cout << str << endl;};
fun1("yyyyyy"); //lambda 不可以直接取地址 无法当作函数指针
auto fun2 = [](double a,double b)->int {return a+b;}; //指定返回值类型为int -> 在()和{}之间 指定返回类型
//内联展开，无法取出地址
//->decltype(a+b) 自动推理类型
auto fun3 = [](double a, int b)->decltype(a+b){return a + b;};
fun3(10, 11); //遵循副本机制
cin.get();
}
高级
#include<array>
#include<algorithm> //算法头文件
void main()
{
int num1 = 10;
int num2 = 11;
[=]() {cout << num1 << " " <<num2<< endl;}(); // = 只能读外部变量 不能写
[&]() {num1 = 50, num2 = 64, cout << num1 << " " << num2 << endl;}(); //& 读写外部变量
[=]()mutable {num1 = 50, num2 = 64, cout << num1 << " " << num2 << endl;}(); // = mutable 修改副本
int a = 10, b = 20, c = 30;
[&a, b, c]() {a = 111, cout << a << " " << b << " " << c << endl;}(); //[&a, b, c] 仅a可读可写 bc只可读
//[a,b,c] mutable 读原本 写副本 =只能指定全部
//2015
[](auto a = 0, auto b = 0) {cout << a + b << endl;}(10.8,11); //C++14 推理数据类型 默认参数只能用=
array<int, 10> myint{1,2,3,4,5,6,7,8,9,10}; //CPP风格叔祖
for_each(myint.begin(), myint.end(), [](int num) {cout << num << endl;}); //显示
for_each(myint.begin(), myint.end(), [&](int num) {num+=1,cout << num << endl;}); //修改
cin.get();
}
函数包装器
#include<functional> //函数包装头文件
using std::function; //函数包装器
void go()
{
cout << "go" << endl;
}
int add(int a, int b)
{
return a + b;
}
void main06x()
{
//返回值 参数
function<void(void)> fun1 = go;
fun1();
function<void(void)> fun2 = []() {cout << "go lambda" << endl;};
fun2();
function<int(int, int)> fun3 = add;
fun3(10,19);
cin.get();
}
模板元
int get50(int n)
{
if (n==1)
{
return 1;
}
else if(n==2)
{
return 2;
}
else
{
return get50(n - 2) + get50(n - 2);
}
}
//递归： 反复调用 函数等待 返回 浪费时间多
//模板元实现递归加速
//执行速度快 编译时候慢 代码体积会增加
//模板元 只能处理常量 把代码的运行时间放在了编译的时间 C11
template<int N>
struct data
{
//递归
enum {res=data<N-1>::res+data<N-2>::res};
};
template<>
struct data<1>
{
enum {res=1};
};
template<>
struct data<2>
{
enum { res = 2 };
};
void main()
{
cout << data<40>::res << endl; //模板元 只能处理常量 把代码的运行时间放在了编译的时间
cout << get50(50) << endl;
cin.get();
}
const
//C语言const 只能避免直接 无法避免间接
//const 在*左边 内容不能改变 在*右边 地址不能改变
void run1(const int *p); //可以改变地址 不能改变内容
void run2(int const *p);
void run3(int* const p); //不可以改变地址 能改变内容
void run4(const int * const p); //bu可以改变地址 不能改变内容
void run5(int const * const p);
void main0xx7()
{
const int n = 10;
int a[n]{0}; //C++编译器自动优化 n替换为10
const int num = 10;
*(int*)(&num) = 3;
cout << (void*)&num << endl;
cout << *(&num) << endl; // 10 读寄存器 自动优化 强行替换为10
int a = 10;
//const int num1 = a;
*(int*)(&num1) = 3;
cout << (void*)&num1 << endl;
cout << *(&num1) << endl; // 3 直接读内存 不作优化
const int numa[5]{ 1,2,3,4,5 };
const int*p = numa;
*(int*)p = 100;
//const数组 没有优化 可以间接改变
//*(p+2)=1; 指向常量的指针 无法修改
cin.get();
}
智能指针
//智能指针 内存泄漏 自动管理内存
void autoptr()
{
while (1)
{
double *p(new double[1024 * 1024]);
auto_ptr<double>autop(p); //接管 自动回收
}
}
void autoptnew()
{
while (1)
{
unique_ptr<double> p(new double[1024 * 1024*10]); //
}
}
tuple
//多元数组 tuple 存取不同的数据类型
#include<tuple>
void main08x()
{
char ch = 'x';
short sh = 1;
int num = 22221;
double db = 123.1;
char*p = "calc";
tuple<char, short, int, double, char*> mytule(ch,sh,num,db,p);
auto autov = get<0>(mytule); //<> 里面只能是常量
cout << autov << endl;
cin.get();
}
