引言

c++11引用非常多的新的编程规范和语法我们进行看一下。

https://github.com/0voice

序列for循环：

简化代码，语法简洁且能避免数组越界，遍历普通数组和stl容器。

#include<iostream>
#include<vector>
using namespace std;
int main(){
//正常for循环
vector<int>a={2,234,23423,4,2,5,6,23};
for(int i=0;i<a.size();i++){
cout<<a[i]<<endl;
}
//序列for循环
for(auto x:a){
cout<<x<<endl;
}
return 0;
}

缺点：无法跳过某个位置。

Lambda表达式（匿名函数）：

可以在需要的时候定义一个临时函数，无需声明，一般试用与stl算法的参数，qt后面的信号与槽用到，让代码更紧凑。

语法：[captyre list](parameter list) mutable exception->return type{function body}

[捕获列表](参数列表) mutable修饰符 异常说明->尾置返回类型{函数体}

#include<iostream>
using namespace std;

int main() {
	int a = 0, b = 2;
	//没有加入关键字
	auto add = [&a, b]() {
		a++; //可以改变
		//b++;值是副本不可以改变
		cout << "a:" << a << "b:" << b << endl;
		};
		//加入关键字
	int a1 = 0, b1 = 2;
	auto add1 = [&a1, b1]()mutable {
		a1++; //可以改变
		b1++;// 值是可以改变的
		cout << "a1:" << a1 << "b1:" << b1 << endl;
		};
	add();
	add1();
	return 0;
}

算法参数：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//正常操作
bool comparefunc(int a,int b){
return a>b;}
int main(){
vector<int> v1={2,6,1,7,8,9,0,4,5};
sort(v1.begin(),v1.end(),comparefunc);
for(auto i:v1){
cout<<i<<endl;}
vector<int> v2={2,6,1,7,8,9,0,4,9,5};
//lambda表达式
sort(v2.begin(),v2.end(),[](int a,int b) ->bool{return a>b});
for(auto i:21){
cout<<i<<endl;}
return 0;
}

委托构造和继承构造：

委托构造函数：

允许同一个类中的构造函数调用另一个构造函数。

作用：

• 避免多个构造函数中重复编写相同的初始化代码；
• 将初始化逻辑集中到一个 “基础构造函数” 中，其他构造函数通过委托复用该逻辑，仅处理自己的特殊参数。

#include<iostream>
using namespace std;
class MyClass{
private:
int x;
double y;
public:
//普通构造函数
MyClass(int a,int b){
x=a;
y=b;
cout<<"普通构造函数"<<endl;}
MyClass(int x):MyClass(x,0.0){
cout<<"委托构造函数一个参数的";
}
MyClass():MyClass(0,0.0){
cout<<"委托构造函数无参"<<endl;
}

};
int main(){
MyClass obj(20,20.6);
MyClass obj1;
MyClass  obj2(33);
return 0;
}

继承构造函数：

派生类继承基类的构造函数

作用：

• 当派生类不需要修改基类构造函数的逻辑，仅需 “复用基类的构造函数来初始化基类部分成员” 时，避免重复定义；
• 尤其适合基类有多个构造函数的场景（如基类有 5 个构造函数，派生类无需逐个重写）

语法：

通过 using 基类名::基类构造函数名（通常直接写 using Base::Base;）在派生类中声明继承基类的所有构造函数：

#include<iostreaam>
using namespace std;
// 基类
class Base {
private:
    int x;
public:
    Base() : x(0) {}
    Base(int a) : x(a) {}
    Base(int a, double b) : x(a) {}  // 基类有3个构造函数
};

// 派生类
class Derived : public Base {
private:
    int y;  // 派生类新增成员
public:
    // 继承基类的所有构造函数
    using Base::Base;  // 关键：声明继承基类构造函数

    // 派生类自己的构造函数（若需要）
    Derived(int a, int b) : Base(a), y(b) {}  // 同时初始化基类和派生类成员
};
int main(){
Derived d1;        // 调用继承的 Base() 构造函数（初始化基类x）
Derived d2(5);     // 调用继承的 Base(int a) 构造函数
Derived d3(3, 4.5);// 调用继承的 Base(int a, double b) 构造函数
Derived d4(2, 3);  // 调用派生类自己的构造函数
return 0;}

总结：

• 普通构造函数是基础，负责类成员的直接初始化；
• 委托构造函数是 “同类内的复用工具”，通过调用同类其他构造函数减少重复代码；
• 继承构造函数是 “跨类（派生类与基类）的复用工具”，让派生类无需重写基类已有的构造函数。

垃圾回收机制：

c++里面没有垃圾回收机制，一般用于手动管理和确定性资源释放（rall）（智能指针，标准容器）；

下面介绍在计算机科学方面4中垃圾回收机制：

总结：

序列for循环用于遍历数组和stl容器

lambda表达式用于算法函数参数的使用，起到简化代码的。

委托构造和继承构造都是为了减少重复代码，提高代码的复用性。

上面的基本都是用与简化代码的。