c++的四种转换方式,完美转发底层如何实现,移动构造语句底层如何实现,auto推演,NULL和nullptr,C++的统一的初始化方案

已于 2022-08-08 15:30:59 修改
阅读量427 收藏 2
点赞数 2
分类专栏： c++笔记 文章标签： c++ 开发语言
于 2022-07-20 11:11:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45510561/article/details/125831047
版权

文章目录

c++的四种转换方式

c语言的转换方式

int main()
{
	int a = 10;
	const int b = 20;
	int* pa = &a;
	int* pb = (int*) &b;//不清楚转换的目的

	float ft = 12.23;
	a = (int)ft;
	float* fp = &ft;
	int* ip = (int*)fp;//不清楚转换的目的
}

基本的数据类型转换
int main()
{
	int a = 20;
	float ft = 12.23;

	a = static_cast<int>(ft);//目的是基本的数据类型转换
	ft = static_cast<float>(a);//ft=(float)a;
	return 0;
}

去常性转换
int main()
{
	const int a = 10;
	int* p = const_cast<int*>(&a);//目的是去常性
	//p = static_cast<int*>(&a); erro

}
指针的转换
int main()
{
	int a = 10;
	int* p = &a;
	//指针的转换
	char* cp = reinterpret_cast<char*>(&a);
}

class Object
{
public:
	virtual void fun() {}
};
class Base :public Object
{
public:
	virtual void fun();
};

动态转换
int main()
{
	Object* op = NULL;
	Base* bp = NULL;
	Object obj;
	Base base;

	op = &base;
	//pb = &obj;err
	op = dynamic_cast<Object*>(&base);
    //只能将子类对象给父类指针
	return 0;
}

移动构造语句底层如何实现

class MyString
{
	char* str;
public:
	MyString(const char* p = NULL):str(NULL)
	{
		if (p!= NULL)
		{
			int len = strlen(p) + 1;
			str = new char[len];
			strcpy_s(str, len, p);
		}
	}
	MyString(const MyString& s) :str(NULL)
	{
		if (s.str != NULL)
		{
			int len = strlen(s.str) + 1;
			str = new char[len];
			strcpy_s(str, len, s.str);
		}
	}
	MyString(MyString&& s) :str(s.str)
	{
		s.str = NULL;
	}
	~MyString()
	{
		if (str != NULL)
		{
			delete []str;
		}
		str = NULL;
	}
};

template<class _Ty>
struct my_remove_reference
{
	using type = _Ty;
	using _Const_thru_ref_type = const _Ty;
};
template<class _Ty>
struct my_remove_reference<_Ty&>
{
	using type = _Ty;
	using _Const_thru_ref_type = const _Ty&;
};
template<class _Ty>
struct my_remove_reference<_Ty&&>
{
	using type = _Ty;
	using _Const_thru_ref_type = const _Ty&&;
};
template<class _Ty>
using my_remove_reference_t = typename my_remove_reference<_Ty>::type;

template<class _Ty>
my_remove_reference_t<_Ty>&& my_move(_Ty&& _Arg)
{
	return static_cast<my_remove_reference_t<_Ty&&>>(_Arg);
}
int main()
{
	/*
	MyString s1("lijiangli");
	MyString s2(s1);
	//移动赋值
	MyString s3(std::move(s1));//s1怎样知道是调动的移动拷贝构造函数
	//MyString s3((MyString&&)s1);
   */
	MyString s1("lijianli");
	const MyString& s2 = s1;
	MyString&& ss = MyString("hello");
	MyString s3(my_move(s2));
	MyString s4(my_move(s1));
	return 0;
}

int &&x=19;
const int &&y=20;//不是右值引用，系统认为它是const int&

多线程的内存池的一些想法

template<int inst>
class Base
{
protected:
	static int num;
public:
	Base()
	{
		num += 1;
	}
	int Getnum() { return num; }
};
template<int inst>
int Base<inst>::num = 0;

int main()
{
	//inst不同产生的对象的版本不同
	Base<0>b1;
	Base<0>b2;
	cout << b1.Getnum() << endl;
	Base<1>c1;
	Base<1>c2;
	Base<1>c3;
	cout << c1.Getnum() << endl;
	return 0;
}

在这里插入图片描述

void print(int& a)
{
	cout << "int&" << endl;
}
void print(const int& a)
{
	cout << "const int&" << endl;
}
void print(int &&a)
{
	cout << "int&&" << endl;
}
template<class _Ty>
void fun(_Ty&& a)
{
	//这里没有左右值之说全是左值
	print(a);
	print(std::forward<_Ty>(a));
}
int main()
{
	int a = 10;
	int& b = a;
	int&& c = 10;
	const int& d = a;
	fun(a);
	fun(b);
	fun(c);
	fun(d);
	fun(20);
	return 0;
}

在这里插入图片描述

完美转发底层如何实现

template<class _Ty>
struct my_remove_reference
{
	using type = _Ty;
	using _Const_thru_ref_type = const _Ty;
};
//部分特化版本
template<class _Ty>
struct my_remove_reference<_Ty&>
{
	using type = _Ty;
	using _Const_thru_ref_type = const _Ty&;
};
template<class _Ty>
struct my_remove_reference<_Ty&&>
{
	using type = _Ty;
	using _Const_thru_ref_type = const _Ty&&;
};
template<class _Ty>
using my_remove_reference_t = typename my_remove_reference<_Ty>::type;

template<class _Ty>
my_remove_reference_t<_Ty>&& my_move(_Ty&& _Arg)
{
	return static_cast<my_remove_reference_t<_Ty>&&>(_Arg);
} 

template<class _Ty>
_Ty&& my_forward(my_remove_reference_t<_Ty>& _Arg) 
{
	return static_cast<_Ty&&>(_Arg);
}
template<class _Ty>
_Ty&& my_forward(my_remove_reference_t<_Ty>&& _Arg) 
{
	return static_cast<_Ty&&>(_Arg);
}
void print(int& a)
{
	cout << "int&" << endl;
}
void print(const int& a)
{
	cout << "const int&" << endl;
}
void print(int &&a)
{
	cout << "int&&" << endl;
}
template<class _Ty>
void fun(_Ty&& a)
{
	//这里没有左右值之说全是左值
	print(a);
	print(std::forward<_Ty>(a));
	print(my_forward<_Ty>(a));
}

int Add(int a, int b)
{
	return a + b;
}
//&+&=>&
//&&+&=>&
//&+&&=>&
//&&+&&=>&&
int main()
{
	int a = 10;
	int& b = a;
	int&& c = 10;
	const int& d = a;
	fun(a);
	fun(b);
	fun(c);
	fun(d);
	fun(20);
	return 0;
}

auto推演

//c11 auto类型推演
int main()
{
	auto x = 10;//auto int
	auto p = new int(10);//auto int *
	auto* s = new int(10);//auto  int
	//auto定义变量时必须进行初始化
	//auto r;erro
	auto ar[]={12,23,34};//erro
}

class Base
{
	//auto val;//erro
	static const auto num = 0;//ok
};

void fun(auto a)//不允许auto 作为函数参数
{
}

int main()
{
	int x = 10;//
	auto* a = &x;//auto int
	auto b = &x;//auto int *
	auto& c = x;//auto int(&和c绑定)
	const int e = 10;
	auto f = e;//auto int(将const省略)
	auto& f2 = e;//auto const int
}

template<class T>
const T& Add(const T&,const T& b)
{
 return a+b;
}
int main()
{
 std::map<int,string>ismap;
 auto it=ismap.begin();
 auto =Add(12,23);//auto可以推演返回值的类型
}

预估值方案

//预给值方案
class Test
{
	int val = 0;
	int *str = NULL;
public:
	Test() = default;
	Test(int x = 10) :val(x), str(NULL) {}
};
int main()
{
	//Test t;没有构造函数之前采用预给值
	Test t1(10);
	Test t2(20);
	return 0;
}

decltype类型推导

int add(int a, int b)
{
	return a + b;
}
//decltype;根据表达式推演出类型
int main()
{
	int a= 10;
	decltype(a)b = 20;
	decltype (a + b)c = 30;
	decltype(add(12, 23))c = 30;
	return 0;
}

NULL与nullptr

void fun(char*)
{
	cout << "fun(char*)" << endl;
}
void fun(int a)
{
	cout << "fun(int a)" << endl;
	cout << a << endl;
}
//nullptr与NULL
/*
 如果是c++NULL为 0
 否则为((void *)))
 具有二义性，为了解决该问题C11提出了nullptr它是空指针常量
*/
int main()
{
	fun(0);
	fun(NULL);
    fun(nullptr);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

统一的初始化方案{}

//C++为了使用模板，有一种统一的初始化方案
int main()
{
	int a = 10;
	int b(10);
	int c = int(0);

	int c{0};
	int d = { 0 };
	int* p = &a;
	int* s{ &a };
	int* r = { &a };
	int* ip{ nullptr };
}

class Object
{
	int value;
public:
	Object(int x=0) :value(x) {}
	Object(int x, int y) :value(x + y) {}
};
vector<int>add()
{
	return { 1,2,3,4 };
}
int main()
{
	int* p = new int{0};
	int* s = new int[] {1, 2, 3, 4};
	Object a();//函数的声明，不产生对象
	Object();//产生无名对象
	Object obja{ 0 };
	Object objb();//没有创建方案，只是函数的声明，之所以用{}就是为了躲避函数的声明
	Object objc{};
	Object* op = new Object[]{ 1,2,3,4,5 };
	Object* op2 = new Object[]{ {1,2},{3,4},{5,6} };
}
丽丽的代码
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中的完美转发
victorydh123的专栏
06-23 1074
C++中的完美转发(perfect-forwarding)到底是什么？说到底，它其实就是一个类型转换，能够将传递到母函数的参数原封不动（这里的原封不动不仅指值不变，还包括类型信息，限定符之类的）在转发给其他函数。 表示形式就是这样:func(expr); //处理函数fwd(expr) { func(std::forward(expr)); //这里省略了很多细节 }fwd就是上面我们说
深入C++四种强制类型转换的总结
09-05
本文将深入探讨C++中的四种强制类型转换：const_cast、dynamic_cast、reinterpret_cast和static_cast，它们各自有着独特的用途和限制。 1. const_cast `const_cast`主要用于改变对象的常量性。在C++中，const修饰的...
c++11中四种类型转换
热门推荐
bian_qing_quan11的博客
04-26 1万+
1、  static_cast: 功能：完成编译器认可的隐式类型转换。 格式type1 a; type2 b = staic_cast(a);将type1的类型转化为type2的类型； 使用范围： （1）基本数据类型之间的转换，如int->double； int a = 6; double b = static_cast(a); （2）派生体系中向上转型：将派生类指针或引用转化为基
[C++中级进阶]001_C++0x里的完美转发到底是神马？
weixin_34355559的博客
01-10 181
问题描述 C++无疑是十分强大的，但是你可知道，在C++0x标准出现之前，在C++界里有一个十分棘手而未能解决的问题——参数转发。问题的描述如下： 对于一个给定的函数E(a1, a2, ..., an)，它有参数a1, a2, ..., an，你不可能写出一个函数F(a1, a2, ..., an)，使得该函数与E(a1, a2, ..., an)完全等价。 对这个问题...
C++四种强制类型转换
weixin_30675247的博客
01-27 174
在C++语言中新增了四个关键字static_cast、const_cast、reinterpret_cast和dynamic_cast。新类型的强制转换可以提供更好的控制强制转换过程。 static_cast static_cast用于将一种数据类型强制转换为另一种数据类型。 int a = 7; int b = 3; double result = static_cast<d...
【C++】dynamic_cast 进行类型转换步骤以及底层实现
最新发布
csxylrf的博客
04-25 976
dynamic_cast 能够进行安全的向下转型，即将一个基类指针或引用转换为派生类指针或引用。，如果无效，返回 NULL 或抛出 std::bad_cast 异常。例如，在向下转型时，如果源指针或引用指向的对象不是目标类型的对象，或者源指针或引用不是指向多态类型的指针或引用，转换就是无效的。，如果不兼容，直接返回 NULL 或抛出 std::bad_cast 异常。** 检查源指针或引用是否为 NULL**，如果是，直接返回 NULL 或抛出 std::bad_cast 异常。
2.const对象-NULL和nullptr-C++中创建对象数组.docx
11-21
在这篇文章中，我们将讨论C++编程语言中的几个重要概念，包括const对象、NULL和nullptr、new和delete操作符、malloc和free函数等。 1.(const对象) 在C++中，const对象是一个不可改变的对象，它的值不能被修改。...
四叉树quadtree的c++实现
06-06
四叉树（Quadtree）是一种数据结构，特别适用于在二维空间中组织和处理点对象。在计算机图形学、地理信息系统和图像处理等领域中，四叉树被广泛应用。它类似于二叉树，但每个节点有四个子节点，分别代表上、下、左、...
用类的方式实现C++链表功能
05-29
本教程将介绍如何使用类的方式来实现一个简单的C++链表，包括链表的创建、插入、删除、修改和查找操作。下面我们将详细探讨这些知识点。 首先，链表的核心是链表节点，通常我们定义一个结构体或类来表示节点，它...
基于C++实现的AStar求解八数码问题.zip
12-12
基于C++实现的AStar求解八数码问题.zip 人工智能课程项目使用说明 Astar类的构造函数包括两部分，首先是启发函数，然后是初始节点； 对于Astar的构造函数而言，初始节点输入为nullptr时，将随机生成初始节点，随机...
C++ 类型转换的实现
一些笔记
01-20 1244
C++类型转换主要分为两种：隐式类型转换、显式类型转换（强制类型转换）。隐式类型转换主要是通过operator（类型转换函数）来实现的；强制类型转换主要用到四个关键字，下面博客内容就按隐式→显式四个关键字 来展开。
C++11 类型转换
wtl666_6的博客
05-26 6298
C++11 类型转换
C++11 右值引用 与 转移语义
weixin_34292924的博客
08-18 192
新特性的目的 右值引用（R-value Reference）是C++新标准（C++11, 11代表2011年）中引入的新特性，它实现了转移语义（Move Semantics）和精确传递（Perfect Forwarding）。主要目的包括两个方面： 1.消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。 2.能够更简洁明确地定义泛型函数。 左值与右值的定义 左值：的定...
C++完美转发实现
senjay的博客
05-23 412
Prefect Forward 实现 ​ 涉及到模板偏特化、万能引用、引用折叠、模板类型推导 1. Move reference ​ 利用模板偏特化，去除引用，保证返回一个不带引用的类型 template<typename T> struct RemoveReference { using type=T; RemoveReference() { std::cout<<"T"<<std::endl; } }; templat
C++完美转发实现原理：万能引用、引用折叠
个人工作中学到的专业技术与职业发展知识笔记
05-23 2204
1、概念： 1.1、万能引用(Universal Reference)： 使用 T&&类型的形参既能绑定右值，又能绑定左值，只有发生类型推导的时候，T&&才表示万能引用 ；否则，表示右值引用。 即万能引用只存在模板中，模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。 1.2、左/右值引用变量的值类型都是左值： 引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值；引用的值类型和变量类型不一样, 左/右值引用变量的值类型都是左值
C++基础知识及相关底层汇编实现（更新中）
最不正经的计算机专业学生
06-27 1701
C++基础
2-2 auto（c++11）、头文件防卫、引用（底层实现）、常量（const、 constexpr（c++11）、nullptr（c++11））
qq_41543888的博客
04-29 2506
目录 auto（c++11） 防卫式声明 引用 C以及C++在const的区别，以及const在C++的增强 nullptr与constexpr（c++11） auto（c++11） 在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。 int a =10 ; //拥有自动生命期 auto int b = 20 ;//拥有自动生命期 st...
[C++]顶层/底层 const , auto
easycome easygoing、
04-11 425
首先区分两个概念： ①顶层：标识符直接指向的数据本身是一个常量，不可改变。 ②底层：通过手段(手段，引用)间接指向数据的手段本身是一个常量，不可改变（指向的数据）。 auto 类型 应用：不知道变量的数据类型而难以提前声明，在不同情况下让编译器替我们分析表达式所属类型。‘’ 普通类型的初始化规则： auto一条语句同时定义多个变量，这些变量的数据类型必须一样。 复合类型的初始化规则： 由直接和间接的思路，我们从两个角度切入：auto 变量 和 auto 指针/引用。 给出示例初始值： .
Modern C++(一)auto自动类型推导
xcyle的口袋
10-28 653
从今天开始，我会将自己一直以来使用C++11的新特性记录下来。作为自己职业生涯的记录以及经验分享。第一篇我给了auto关键字，这是因为实际使用中，确实auto给我们开发效率提升了很多，确实使用的也算是最广。在C++11之前已经有了auto，它指代的是“一个自动存储变量的关键字，也就是申明一块临时的变量内存”，比如：auto int i = 5; 我们很少使用，因为非static的变量本身就是自动存储
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值