C++入门3(C++新特性 using string auto map与迭代器失效 )

IT_涛涛

已于 2023-08-18 22:07:40 修改

阅读量697

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-05-01 22:21:35 首次发布

本文链接：https://blog.csdn.net/weixin_61785714/article/details/130459427

版权

C++ 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

C++入门3

C++新特性

auto推导规则

auto类型推导: auto定义的变量，可以根据初始化的值，在编译时推导出变量名的类型。c11中auto不再表示存储类型指示符,auto定义变量时，该变量一定给与初始化。

int main(){
	auto x = 5; // l ok x 是int类型
	auto pi = new auto(1);// okpi被推导为int * ;
	const auto *xp = &x，u = 6;l// ok xp是const int*类型，u是const int类型
	static auto dx = 0.0;l // ok dx 是 doub1e类型
	auto int b;
	// error c11中auto不再表示存储类型指示符
	auto s ;
	// error没有初始化值 auto无法推导出s的类型

连在一起写，容易出现二义性，最好分开写

intmain({
	auto x = 5;
	// ok x 是int类型
	const auto *xp = &x,u;
	//?
	const auto *ip = &x，u = 6.0; //?
	return 0;
}

和指针引用结合起来使用，const结合

int main({
	int x = 0 ;
	auto *ip = &x;// ok ip ->int*，auto被推导为int
	auto xp = &x ;// ok xp -> int*  ,auto被推导为int*
	auto &c = x;// ok c -> int &，auto被推导为int
	auto d = x;// ok d -> int , auto被推导为int
	const auto e = x;  ok e ->const int;
	autof = e;// okf -> int;
	const auto &g = x; // ok g -> const int &
	auto & h = g;// ok h -> const int &
}

auto 作为函数的形参类型

注意auto&x=ar，就是一个数组的别名，即
int(&br)[5]=ar; auto 推导为int[5];他们等价

void func(auto x){
	cout << sizeof(x) << endl ;
	cout << typeid(x ).name() << endl ;
}
int mainO{
	int a = 10;
	int ar[]={12,23,34,45,56};
	func(a);//  4 int
	func(ar);// 4 int*    退化成指针
}
//**************************************
void func(auto &x){
	cout << sizeof(x) << endl ;
	cout << typeid(x).name( << endl ;
}
int main({
	int a = 10;
	int ar[={12,23,34,45,56};
	func(a);//4  int
	func(ar);//20  int [5]

注意:auto 不能在结构体使用，auto无法定义数组；

int main(){
	int ar[10]={0};
	auto br=ar;//br->int*
	auto cr[10]=ar;//error   
	auto dr[5]={1,2,3,4,5};//error

基于范围for循环

for(ElemType val : array){
	..// statement循环体
}

ElemType 一般写成auto，让编译器自己推演，array是容器或者数组,不能是结构体
容器有vector array list map unordered_map set unordered_set

int main(){
	int ar[]={1,2,3,4,5,6,7,8,9,10};
	int*p=ar;
	auto&x=ar;//等价int(&br)[10]=ar;
	int(&br)[10]=ar;
	//下面哪个不能编译通过：
	for(auto&val:p){}//error：后面必须是数组或者容器
	for(auto&val:x){}//x是ar的别名
	for(auto&val:br){}//br是ar的别名

核心用法，可以打印一个二维数组

int main(){
	int ar[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
	for(auto&x:ar){//x就是一个数组的别名
		for(auto val:x){
			cout<<val<<endl;
		}
	}
}

打印了三个地址

int main() {
	int ar[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
	for (auto x : ar) {//x是一个地址,ar[0]  ar[1]  ar[2]
		cout << x<<' ';
		cout << endl;
	}
}

auto与迭代器

迭代器就像个对象，类似智能指针，就是一个指针，指向该内容，往后遍历一遍

#include<iostream>
#include<map>
#include<vector>
using namespace std;
int main()
{
	//map中的一一对应一个【string的值】和【int的值】一一对应的
	map<string, int>mp;
	mp["student_1"] = 1;
	mp["student_2"] = 2;
	mp["student_3"] = 3;
	cout << mp["student_2"] << endl;

	auto ptr = mp.begin();
	cout << ptr->first << endl;
	cout << ptr->second << endl;
	//迭代器的类型要和上面定义的对应,
	//上面定义的是mp<string,int>mp，下面的迭代器也是要map<string,int>::iterator
	//map<string, int>::iterator iter;
	auto iter = mp.begin();
	//先让iter指向mp的开头，到mp的末尾结束；
	for (; iter != mp.end(); iter++) {
		//iter->first指向第一个即string,iter->指向第二个即int
		cout << iter->first << "  " << iter->second << endl;
	}

	vector<int>vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	auto p = vec.begin();
	while (p != vec.end()) {
		cout << *p << endl;
		p++;
	}
	

	return 0;
}

在这里插入图片描述

迭代器失效问题

往vector、string、deque等容器添加元素，可能会使得相关的迭代器、引用、地址等全部失效，因为元素的添加过程可能会导致原有元素的内存地址变生变化。

插入失效

insert在迭代器it所指向的元素前，新增一个元素，函数返回指向新增元素的迭代器
在这里插入图片描述


int main() {
    std::vector<int>vec{ 1,2,3,6 };
    auto it = vec.begin();
    vec.insert(it, 9);
    for (auto& x : vec) {
        cout << x;
    }
    cout << endl;
    return 0;
}

在这里插入图片描述

删除失效

erase 删除迭代器所指向的元素，返回一个迭代器，指向被删除元素的后一个元素。
在这里插入图片描述


int main() {
    std::vector<int>vec{ 1,2,3,6 };

    auto it = vec.begin();
    while (it != vec.end()) {
        if (*it == 2) {
            it = vec.erase(it);
        }
        else {
            it++;
        }   
    }
    for (auto& x : vec) {
        cout << x;
    }
    cout << endl;
    return 0;
}

实例

将 1,-2,3,-6负数删除，正数复制一份

int main() {
    std::vector<int>vec{ 1,-2,3,-6 };

    auto it = vec.begin();
    while (it != vec.end()) {
        if (*it < 0) {
            it = vec.erase(it);
        }
        else {
            it = vec.insert(it, *it);
            it += 2;
        }   
    }
    for (auto& x : vec) {
        cout << x;
    }
    cout << endl;
    return 0;
}

在这里插入图片描述

decltype

exp表示一个表达式(expression) 。
从格式上来看，decltype很像sizeof-—用来推导表达式类型大小的操作符。类似于sizeof,decltype 的推导过程是在编译期完成的，并且不会真正计算表达式的值。

int main({
	int x = 10;
	decltype(x) y = 1;// y => int
	decltype(x+y) z = 0; // y = int;
	const int &i = x;
	decitype(i)j= y;// j = const int & ;
	const dec1type(z) *p = &z;//*p => const int , p = const int *
	dec1type (z) *ip = &z; // *ip => int , ip => int *
	dec1type(pi) *pp = &ip // *pp => int *，pp => int ;

typedef与using

C语言定义变量

typedef 可以把一切合法的变量的定义改成类型名

struct Node{
	char s_id[10];
	int s_age
}
struct Node Node;
unsigned int u_int;
int array[10];
int* PINT;
int (*pfun)(int) ;

可以把结构体合二为一

typedef struct Node{
	char s_id[10];
	int s_age
}Node;

typedef 在C语言中的写法

typedef struct Node{
	char s_id[10];
	int s_age
}
typedef unsigned int u_int;
typedef int array[10];
typedef int* PINT;
typedef int (*pfun)(int) ;
typedef struct Node Node;
int main ()
{
	u_int x,y;
	array ar,br;
	PINT xp,yp;
	pfun pf1,pf2;
	Node n1,n2;
}

using在C++11中的写法

typedef struct Node{
	char s_id[10];
	int s_age
}
using u_int= unsigned int ;
using array= int[10];
using PINT=int*;
uisng pfun=int(*)(int) ;//函数指针
using Node=struct Node;
int main ()
{
	u_int x,y;
	array ar,br;
	PINT xp,yp;
	pfun pf1,pf2;
	Node n1,n2;
}

using与template的结合

<>里面是什么类型，就定义什么类型的指针

template<class T>
using Pointer=T*;
int main(){
	int a=10;
	Pointer<int>p=&a;//p是整型指针
	return 0;
}

string的简单使用

在其他文章里详细介绍了C++常用的字符串：
链接: C++字符串

int main(){
	char str[20]={"yhping"};
	str[0]='x';
	const char str1="yhping";

int main (){
	char stra[20] = "yhping" ;
	char strb[20] = "yhping";
	const char* cp1 = "yhping" ;
	const const*cp2 = "yhping";
	cout<<(stra == strb) << endl ;
	cout<< (cp1==cp2) << endl;
	return 0;