标签：11 return 函数 int 特性 线程 C++ str const
1 列表初始化
1.1 内置类型的列表初始化
int main()
{
// 内置类型变量
int x1 = {10};
int x2{10};
int x3 = 1+2;
int x4 = {1+2};
int x5{1+2};
// 数组
int arr1[5] {1,2,3,4,5};
int arr2[]{1,2,3,4,5};
// 动态数组，在C++98中不支持
int* arr3 = new int[5]{1,2,3,4,5};
// 标准容器
vector<int> v{1,2,3,4,5};
map<int, int> m{{1,1}, {2,2,},{3,3},{4,4}};
return 0;
}
1.2 自定义类型的列表初始化
多个对象本身不支持列表初始化，多个对象想要支持列表初始化，需给该类(模板类)添加一个带有initializer_list类型参数的构造函数即可。
template<class T>
class Vector {
public:
// ...
Vector(initializer_list<T> l) : _capacity(l.size()), _size(0)
{
_array = new T[_capacity];
for (auto e : l)
_array[_size++] = e;
}
Vector<T>& operator=(initializer_list<T> l) {
delete[] _array;
size_t i = 0;
for (auto e : l)
_array[i++] = e;
return *this;
}
// ...
private:
T* _array;
size_t _capacity;
size_t _size;
};
//自定义类型容器用初始化列表
//用自定义类型的容器类进行初始化，需要定义一个构造函数，参数为initializer_list
Vector<int> v2{ 1,2,3 };
Vector<int> v3 = { 1 };
2 decltype变量类型推导
decltype():根据表达式的实际类型推演出定义变量时所用的类型。
int fun(int a)
{
return a;
}
void test01()
{
auto a = 10;
int b = 1;
int c = 2;
// 用decltype推演b+c的实际类型，作为定义d的类型
decltype(b + c) d;
cout << typeid(d).name() << endl;
// 如果带参数列表，推导的是函数返回值的类型,注意：此处只是推演，不会执行函数
cout << typeid(decltype(fun(a))).name() << endl;
// 如果没有带参数，推导函数的类型
cout << typeid(decltype(fun)).name() << endl;
}
3 默认成员控制
3.1 显示缺省函数
在C++11中，可以在默认函数定义或者声明时加上**=default**，从而显式的指示编译器生成该函数的默认版本，用=default修饰的函数称为显式缺省函数。
class A {
public:
A(int a): _a(a)
{}
// 显式缺省构造函数，由编译器生成
A() = default;
//由编译器生成一个拷贝构造函数
A(const A&a)=default;
// 在类中声明，在类外定义时让编译器生成默认赋值运算符重载
A& operator=(const A& a);
private:
int _a;
};
A& A::operator=(const A& a) = default;
int main()
{
A a1(10);
A a2;
a2 = a1;
return 0; }
3.2 删除默认函数
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且不给定义，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上**=delete**即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
注意：避免删除函数和explicit一起使
//delete:该语法指示编译器不生成对应函数的默认版本，称 = delete修饰的函数为删除函数。
class B
{
public:
B(){}
//成员函数定义为删除函数，表示函数不能被调用
//防拷贝：把拷贝构造和赋值运算符定义为delete
// 禁止编译器生成默认的拷贝构造函数以及赋值运算符重载
B(const B&) = delete;
B& operator=(const B&) = delete;
};
void test()
{
B b;
// 编译失败，因为该类没有拷贝构造函数
//B copy(b);
// 编译失败，因为该类没有赋值运算符重载
//b = copy;
}
4 右值引用
4.1 左值与右值
void test()
{
//左值：可以出现现在“=”两边
//右值：只能出现在“=”右边
//左值：可以取地址
//右值不：能取地址
//但是上面两种分类都不是完全正确
int a = 10;
int b = a;
//10 = b;//错误
int* pa = &a;
//int* pi = &10;
//C++11中的区分方式
//右值：常量、临时变量/匿名变量、将亡值
b = fun(1);
b = fun(a);
//fun(a) = a;
//右值不可以取地址
//int* pa2 = &(fun(a));
}
4.2 左值引用与右值引用
// 普通引用只能引用左值，不能引用右值，const引用既可引用左值，也可引用右值
void test()
{
//左值引用：可以引用左值
int a = 10;
int& ra = a;
//常量引用
const int& ri = 10;
const int& ri2 = fun(a);
//右值引用&&：只能引用右值，不能引用左值
//int&& ra = a;
int&& rri = 10;
int&& tt = fun(a);
}
4.3 移动语义
class String
{
public:
String(char* str = "")
{
if (nullptr == str)
str = "";
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
String(const String& s)
: _str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}
String& operator=(const String& s)
{
if (this != &s)
{
char* pTemp = new char[strlen(s._str) +1];
strcpy(pTemp, s._str);
delete[] _str;
_str = pTemp;
}
return *this;
}
String operator+(const String& s)
{
char* pTemp = new char[strlen(_str) + strlen(s._str) + 1];
strcpy(pTemp, _str);
strcpy(pTemp + strlen(_str), s._str);
String strRet(pTemp);
return strRet;
}
~String()
{ if (_str) delete[] _str;}
private:
char* _str;
};
int main()
{
String s1("hello");
String s2("world");
String s3(s1+s2);
return 0; }
strRet在按照值返回时，必须创建一个临时对象，临时对象创建好之后，strRet就被销毁了，最后使用返回的临时对象构造s3，s3构造好之后，临时对象就被销毁了。仔细观察会发现：strRet、临时对象、s3每个对象创建后，都有自己独立的空间，而空间中存放内容也都相同，相当于创建了三个内容完全相同的对象，对于空间是一种浪费，程序的效率也会降低，而且临时对象确实作用不是很大。
//移动构造：使用移动语义，把对象中的资源移动到另一个对象
class String
{
public:
String(char* str = "")
{
if (nullptr == str)
str = "";
_str = new char[strlen(str) + 1];
strcpy(_str, str);
}
String(const String& s)
: _str(new char[strlen(s._str) + 1])
{
strcpy(_str, s._str);
}
String& operator=(const String& s)
{
if (this != &s)
{
char* pTemp = new char[strlen(s._str) + 1];
strcpy(pTemp, s._str);
delete[] _str;
_str = pTemp;
}
return *this;
}
//右值引用，浅拷贝
String(String&& s)
:_str(s._str)
{
s._str = nullptr;
cout << "String(String&& s)" << endl;
}
String& operator=(String&& s)
{
if (this != &s)
{
_str = s._str;
s._str = nullptr;
}
}
String operator+(const String& s)
{
char* pTemp = new char[strlen(_str) + strlen(s._str) + 1];
strcpy(pTemp, _str);
strcpy(pTemp + strlen(_str), s._str);
String strRet(pTemp);
return strRet;
}
~String()
{
if (_str) delete[] _str;
}
private:
char* _str;
};
int main()
{
String s1("hello");
String s2("world");
cout << "copy" << endl;
String s3(s1 + s2);
String s4(s2);
cout << "---" << endl;
s4=s1+s2;
cout << "-----" << endl;
}
因为strRet对象的生命周期在创建好临时对象后就结束了，即将亡值，C++11认为其为右值，在用strRet构造临时对象时，就会采用移动构造，即将strRet中资源转移到临时对象中。而临时对象也是右值，因此在用临时对象构造s3时，也采用移动构造，将临时对象中资源转移到s3中，整个过程，只需要创建一块堆内存即可，既省了空间，又大大提高程序运行的效率。
4.4 右值引用引用左值
int main()
{
String s1("hello");
String s2("world");
cout << "copy" << endl;
String s3(s1 + s2);
String s4(s2);
cout << "---" << endl;
s4=s1+s2;
cout << "-----" << endl;
//move:将一个左值强制转化为右值引用，然后实现移动语义
String&& rs = std::move(s3);
//错误的使用
//s3将资源转移到s6,s3的资源将无法使用，s3变为无效字符串
String s6(move(s3));
return 0;
}
正确使用move的例子
class Person
{
public:
Person(char* name, char* sex, int age)
: _name(name)
, _sex(sex)
, _age(age)
{}
Person(const Person& p)
: _name(p._name)
, _sex(p._sex)
, _age(p._age)
{}
#if 0
Person(Person&& p)
: _name(p._name)
, _sex(p._sex)
, _age(p._age)
{}
#else
Person(Person&& p)
: _name(move(p._name))
, _sex(move(p._sex))
, _age(p._age)
{}
#endif
private:
String _name;
String _sex;
int _age;
};
Person GetTempPerson()
{
Person p("prety", "male", 18);
return p; }
int main()
{
Person p(GetTempPerson());
return 0; }
4.5 完美转发
完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。
//C++11通过forward<T>()函数来实现完美转发
void Fun(int& x) { cout << "lvalue ref" << endl; }
void Fun(int&& x) { cout << "rvalue ref" << endl; }
void Fun(const int& x) { cout << "const lvalue ref" << endl; }
void Fun(const int&& x) { cout << "const rvalue ref" << endl; }
template<typename T>
//T&&：未定义引用类型，并不是右值引用
void PerfectForward(T&& t) { Fun(std::forward<T>(t)); }
int main()
{
PerfectForward(10); // rvalue ref
int a;
PerfectForward(a); // lvalue ref
PerfectForward(std::move(a)); // rvalue ref
const int b = 8;
PerfectForward(b); // const lvalue ref
PerfectForward(std::move(b)); // const rvalue ref
return 0;
}
5 lambda表达式
5.1 什么是仿函数
struct Greater
{
//仿函数类：重载()
bool operator()(const T& a, const T& b)
{
return a > b;
}
};
struct MyPlus {
int operator()(const int& a, const int& b) const {
return a + b;
}
};
void test01()
{
Greater<int> g;
bool ret=g.operator()(10, 20);
ret = g(10, 20);//等价于g.operator()(10,20)
}
void test02()
{
MyPlus a;
cout << MyPlus()(1, 2) << endl;//1、通过产生临时对象调用重载运算符
cout << a.operator()(1, 2) << endl;//2、通过对象显示调用重载运算符
cout << a(1, 2) << endl;//3、通过对象类似函数调用 隐示地调用重载运算符
return 0;
}
5.2 为什么要写lambda表达式
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。
int main()
{
int array[] = {4,1,8,5,3,7,0,9,2,6};
// 默认按照小于比较，排出来结果是升序
std::sort(array, array+sizeof(array)/sizeof(array[0]));
// 如果需要降序，需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
return 0; }
如果待排序元素为自定义类型，需要用户定义排序时的比较规则：
struct Goods
{
string _name;
double _price;
};
struct Compare
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price <= gr._price;
}
};
int main()
{
Goods gds[] = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝", 1.5} };
sort(gds, gds+sizeof(gds) / sizeof(gds[0]), Compare());
return 0; }
随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一algorithm算法， 都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C11语法中出现了Lambda表达式。
int main()
{
Goods gds[] = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝", 1.5} };
sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& l, const Goods& r)
->bool
{
return l._price < r._price;
});
return 0; }
上述代码就是使用C++11中的lambda表达式来解决，可以看出lamb表达式实际是一个匿名函数。
5.3 lambda表达式语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
- lambda表达式各部分说明
[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意： 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
void test()
{
//lamba表达式：[捕捉列表](参数列表）（mutable可选）->返回值类型（函数体）
//捕捉列表：捕获父作用域中的变量
int a = 10;
int b = 20;
[a, b] {return a + b; };
//参数列表：类似函数列表
[a, b](int c, int d, int e) {return a + b + c; };
//返回值：类似函数返回值
[a, b](int c)->int {return a + b + c; };
//函数体：类似于函数的函数体，可以有多句指令
//mutable:修改捕捉列表中变量的属性为非const,默认const属性
//[a, b](int c)->int {a = 10};//a,b的属性不能修改创，默认为const
//要修改捕捉列表中的值，需要加mutable关键字
[a, b](int c)mutable->int {a = 100; b = 200; return a; };
//在没有mutable的情况下，参数列表返回值可以省略
[] {};
//返回值类性一般不用写，编译器会自动推导
[a, b] {return a + b; };
//如果有mutable，即使参数列表为空，也需要显示写出来
//[a, b]mutable {return a + b; };
[a, b]()mutable {return a + b; };
auto f = [a, b](int c) {return a + b + c; };
//以上都是定义，不会运行
//运行
int e = f(10);
//[=],以值的形式捕捉父作用域中的所有变量
auto f2 = [=] {return a + b + e; };
//[&],以引用的方式捕捉父作用域中的所有变量
auto f3 = [&]() {a = 1; b = 1000; };
//[=,&变量x]:x引用形式捕捉，其他的以值的形式捕捉
//错误的捕捉方式：[=,变量x],[&,&变量x]
//[&,变量x]:x值得形式捕捉。其他的以引用的形式捕捉
auto f4 = [&, a]() {return a + b; };
auto f5 = [=, &a, &e]() {return a + b + e; };
//[this]:捕捉成员函数的this指针
struct A
{
void fun(int a)
{
auto f = [this]() {return _a; };
}
int _a;
};
}
5.4 lambda表达式的性质
//lambda表达式一些性质
typedef int(*ptr)(int);
void test()
{
auto f = [](int a) {return a; };
auto f2 = [](int a) {return a; };
//1.lambda表达式不能进行赋值，即使类型相同
//f = f2;
//2.允许lambda表达式拷贝
auto copy(f);
//3.可以赋值给函数指针
ptr f4 = f;
}
//如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()
struct Sum
{
int operator()(int a, int b)
{
return a + b;
}
};
void test()
{
auto f = [](int a, int b) {return a + b; };
int sum = f(10, 20);
Sum s;
s(10, 20);
}
5.5 线程库
//线程库
void fun(int a)
{
cout << "fun(int a)" << endl;
}
struct Fun
{
void operator()()
{
cout << "Fun operator()" << endl;
}
};
void test()
{
thread t();
// 1.线程函数为函数指针
thread t1(fun, 10);
//判断线程是否结束
t1.joinable();
//阻塞进程
t1.join();
//2.仿函数对象
Fun f;
thread t2(f);
t2.join();
//3.lambda表达式
thread t3([] {cout << "lambda" << endl; });
t3.join();
}
5.6 线程函数参数
class A
{
public:
void fun1(int a, int b)
{
cout << "fun1(int,int)" <<" "<< a <<" "<< b << endl;
}
};
void fun(int& a)
{
a += 10;
}
void fun1(int* atr)
{
*atr += 10;
}
void test()
{
A a;
//成员函数需要显示取地址
thread t1(&A::fun1, &a,10, 20);
t1.join();
// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际引用的是线程栈中的拷贝
/*int a2 = 1;
thread t2(fun, a2);
t2.join();
cout << a2 << endl;*/
地址的拷贝
int a3 = 1;
thread t3(fun1, &a3);
cout << a3 << endl;
t3.join();
//参数如果是引用类型,需要加ref转换
thread t4(fun, ref(a3));
cout << a3 << endl;
t4.join();
}
5.7 join与detach
启动了一个线程后，当这个线程结束的时候，如何去回收线程所使用的资源呢？thread库给我们两种选择：
join()方式
join()：主线程被阻塞，当新线程终止时，join()会清理相关的线程资源，然后返回，主线程再继续向下执行，然后销毁线程对象。由于join()清理了线程的相关资源，thread对象与已销毁的线程就没有关系了，因此一个线程对象只能使用一次join()，否则程序会崩溃。
detach()方式
detach()：该函数被调用后，新线程与线程对象分离，不再被线程对象所表达，就不能通过线程对象控制线程了，新线程会在后台运行，其所有权和控制权将会交给c++运行库。同时，C++运行库保证，当线程退出时，其相关资源的能够正确的回收。
就像是你和你女朋友分手，那之后你们就不会再有联系（交互）了，而她的之后消费的各种资源也就不需要你去埋单了（清理资源）。
****detach()函数一般在线程对象创建好之后就调用，因为如果不是jion()等待方式结束，那么线程对象可能会在新线程结束之前被销毁掉而导致程序崩溃。因为std::thread的析构函数中，如果线程的状态是jionable，std::terminate将会被调用，而terminate()函数直接会终止程序。
void fun2(int n)
{
for (int i= 0; i < n; i++)
{
cout << i << " ";
}
cout << "fun2..." << endl;
}
void test()
{
//detach()：该函数被调用后，新线程与线程对象分离，不再被线程对象所表达，就不能通 //过线程对象控制线程了，新线程会在后台运行，其所有权和控制权将会交给c++运行库。同时//C++运行库保证，当线程退出时，其相关资源的能够正确的回收。
thread t1(fun2, 1000);
t1.detach();
cout << "test" << endl;
}
//采用jion()方式结束线程时，jion()的调用位置非常关键。为了避免该问题，可以采用RAII的方式对线程对象进行封装，
class ThreadManger
{
public:
ThreadManger(thread& t)
:_t(t)
{}
~ThreadManger()
{
if (_t.joinable())
{
_t.join();
}
}
private:
thread& _t;
};
void test()
{
thread t1([] {});
ThreadManger tm(t1);
vector<int> v;
v.at(3) = 10;
//在这会正常结束
//return;
t1.join();
}
int main()
{
try
{
test();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
5.8 原子操作
多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。比如：
#include <iostream>
using namespace std;
#include <thread>
unsigned long sum = 0L;
void fun(size_t num) {
for (size_t i = 0; i < num; ++i)
sum++; }
int main()
{
cout << "Before joining,sum = " << sum << std::endl;
thread t1(fun, 10000000);
thread t2(fun, 10000000);
t1.join();
t2.join();
cout << "After joining,sum = " << sum << std::endl;
return 0; }
C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。
#include <thread>
#include <mutex>
std::mutex m;
unsigned long sum = 0L;
void fun(size_t num) {
for (size_t i = 0; i < num; ++i)
{
m.lock();
sum++;
m.unlock();
}
}
int main()
{
cout << "Before joining,sum = " << sum << std::endl;
thread t1(fun, 10000000);
thread t2(fun, 10000000);
t1.join();
t2.join();
cout << "After joining,sum = " << sum << std::endl;
return 0; }
虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。
因此C++11中引入了原子操作。所谓原子操作：即不可被中断的一个或一系列操作，C++11引入的原子操作类型，使得线程间数据的同步变得非常高效。
//原子操作
atomic<int> sum(0);
void fun(int n)
{
for (int i = 0; i < n; i++)
{
//不是原子操作，加atomic串行操作,或者加解锁
//mtx.lock();
sum++;
//mtx.unlock();
}
}
void test()
{
int n;
cin >> n;
thread t1(fun, n);
thread t2(fun, n);
t1.join();
t2.join();
cout << sum << endl;
}
5.9 lock_guard
//死锁
mutex mtx;
template<class Mtx>
class LockGuard
{
public:
LockGuard(Mtx& mtx)
:_mtx(mtx)
{
//在构造函数中加锁
mtx.lock();
}
~LockGuard()
{
//在析构函数中解锁
mtx.unlock();
}
//保证一把锁只能被一个对象管理
LockGuard& operator=(const LockGuard&) = delete;
LockGuard(const LockGuard&) = delete;
private:
Mtx& _mtx;
};
void fun1()
{
//通过智能指针自动管理资源
LockGuard<mutex> lg(mtx);;
cout << "fun1()" << endl;
int n;
cin >> n;
//两个函数用同一把锁，在这里会产生死锁
//因为这里发生异常，线程直接退出，fun2()产生死锁
//通过lock_guard可以有效避免死锁
if (n == 0)
return;
mtx.unlock();
}
void fun2()
{
LockGuard<mutex> lg(mtx);
mtx.lock();
cout << "fun2()" << endl;
mtx.unlock();
}
void test()
{
thread t1(fun1);
thread t2(fun2);
t1.join();
t2.join();
}
通过上述代码可以看到，lock_guard类模板主要是通过RAII的方式，对其管理的互斥量进行了封装，在需要加锁的地方，只需要用上述介绍的任意互斥体实例化一个lock_guard，调用构造函数成功上锁，出作用域前，lock_guard对象要被销毁，调用析构函数自动解锁，可以有效避免死锁问题。
标签：11,return,函数,int,特性,线程,C++,str,const 来源： https://blog.csdn.net/qq_51681435/article/details/120935897
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。