C语言和C++的类型转换

最新推荐文章于 2024-03-13 20:32:08 发布
最新推荐文章于 2024-03-13 20:32:08 发布
阅读量1k 收藏 21
点赞数 23
分类专栏： C++ 小概念整理 文章标签： c语言 c++ 开发语言 类型转换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73898917/article/details/136193010
版权

文章目录

一、算术转换

算术转换（arithmetic conversion）的含义是把一种算术类型转换成另外一种算术类型。算术转换的规则定义了一套类型转换的层次，其中运算符的运算对象将转换成最宽的类型。例如，如果一个运算对象的类型是 long double ，那么不论另外一个运算对象的类型是什么都会转换成 long double。 还有一种更普遍的情况，当表达式中既有浮点类型也有整数类型时，整数值将转换成相应的浮点类型。

可以参考这篇文章：【C语言】深入理解C语言中的整型提升和算术转换


整形提升

整型提升是将较小的整数类型转换为较大的整数类型的过程。通常发生在以下情况：

  • 当操作数的类型比int类型更小（例如：char, short）时，会自动提升为int类型。
  • 当操作数的类型是无符号的（例如：unsigned char, unsigned short），并且可以在不丢失任何信息的情况下转换为int类型，则提升为int类型；否则，提升为unsigned int类型。

整型提升的主要目的是确保数据在计算过程中能够正确处理，避免因较小类型溢出而导致的错误。


算术转换

请添加图片描述

请添加图片描述


二、隐式类型转换

在下面这些情况下，编译器会自动地转换运算对象的类型：

  • 在大多数表达式中，比int类型小的整型值首先提升为较大的整数类型。
  • 在条件中，非布尔值转换成布尔类型。
  • 初始化过程中，初始值转换成变量的类型；在赋值语句中，右侧运算对象转换成左侧运算对象的类型。
  • 如果算术运算或关系运算的运算对象有多种类型，需要转换成同一种类型。
  • 函数调用时也会发生类型转换。

三、显式类型转换

C语言旧式的类型转换

对于C/C++，类型转换发生在下面三种情况下：

  1. 赋值运算符左右两侧类型不同
  2. 形参与实参类型不匹配
  3. 返回值类型与接收返回值类型不一致时

1. C语言隐式类型转换

#include <stdio.h>

int main()
{
	int i = 1;
	// 隐式类型转换
	double d = i;
	printf("%d, %.2f\n", i, d);
}

输出结果：
1, 1.00

2. C语言显式的类型强转

#include <stdio.h>

int main()
{
	int* p = &i;
	// 显式的强制类型转换
	int address = (int)p;
	printf("%p, %d\n", p, address);
	return 0;
}

输出结果：
00000046857EF584, -2055277180

C语言类型强转的缺陷:

  • 转换的可视性比较差
  • 所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换

因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。


C++引入的四种显式类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：
static_cast、reinterpret_cast、const_cast、dynamic_cast

转换的形式：

castname<type>(expression);

其中：

  • type是转换的目标类型而expression是要转换的值，如果type是引用类型，则结果是左值。
  • castname是static_cast、reinterpret_cast、const_cast、dynamic_cast四种。

1. static_cast

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用
static_cast，它适用于基本数据类型之间的转换或者具有继承关系的类之间的转换，但它不能用于两个不相关的类型进行转换。

基本数据类型之间的转换
#include <iostream>

int main() 
{
    double doubleValue = 3.14;
    int intValue = static_cast<int>(doubleValue);

    std::cout << "Double value: " << doubleValue << std::endl;
    std::cout << "Converted to int: " << intValue << std::endl;

    return 0;
}

在这个例子中，static_cast被用于将double类型转换为int类型。这种转换会截断小数部分，只保留整数部分。

类指针之间的转换：
#include <iostream>

class Base {
public:
    virtual void print() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived class" << std::endl;
    }
};

int main() {
    Derived derivedObj;
    Base* basePtr = &derivedObj;

    // 使用 static_cast 进行基类指针到派生类指针的转换
    Derived* derivedPtr = static_cast<Derived*>(basePtr);

    derivedPtr->print();  // 输出 "Derived class"

    return 0;
}

在这个例子中，static_cast被用于将基类指针转换为派生类指针。这种转换只在确保基类指针指向的实际对象是派生类对象的情况下才是安全的。

枚举类型之间的转换
#include <iostream>

enum class Color { RED, GREEN, BLUE };

int main() {
    int blueValue = static_cast<int>(Color::BLUE);

    std::cout << "Integer value for BLUE: " << blueValue << std::endl;

    return 0;
}

在这个例子中，static_cast被用于将枚举类型Color的成员转换为整数类型。这可以用于在需要整数值的情况下使用枚举。

C 语言风格的强制类型转换和 static_cast 之间的差异
int main()
{
	int a = 123;
	int* int_ptr = &a;
	char* char_ptr1 = int_ptr; // 编译错误
	char* char_ptr2 = (char*)int_ptr; // 没有编译错误，语法允许
	char* char_ptr3 = static_cast<char*> (int_ptr); // 编译错误：类型转换无效
}

  • char* char_ptr1 = int_ptr; 使用的是 C 语言风格的强制类型转换，它将 int* 类型的指针直接赋值给 char* 类型的指针，这在语法上是允许的，但它存在潜在的问题。这样的强制类型转换可能会导致未定义行为，因为在将整数指针转换为字符指针时，可能会造成指针间隔不一致，访问越界等问题。

  • char* char_ptr2 = (char*)int_ptr; 中使用的是 C 语言风格的强制类型转换，这是合法的，但仍然存在潜在的问题。这种转换通常被视为一种“原始”转换，可能会导致指针的类型不匹配，从而引发运行时错误。

  • char* char_ptr3 = static_cast<char*>(int_ptr); 使用了 static_cast 进行类型转换，这种转换是相对更为安全的，但在这个特定的情况下它会产生编译错误。static_cast 对于不同类型的指针之间的转换会进行更为严格的检查，确保类型之间有合理的关系，而在这个例子中，由于 int* 和 char* 之间的关系并非直接的继承关系，因此编译器会报错。


2. const_cast

const_cast最常用的用途就是删除变量的const属性，方便赋值。

  • 如果指针或引用指向或绑定的对象本身不是一个常量，使用强制类型转换获得写权限是合法的行为。
  • 然而如果该对象是一个常量，再使用 const_cast 执行写操作，虽然不会编译报错，但是会产生未定义的后果。
#include <iostream>

int main() 
{
    int nonConstValue = 42;
    const int* constPtr = &nonConstValue;

    // 使用 const_cast 删除 const 属性
    int* nonConstPtr = const_cast<int*>(constPtr);

    // 修改变量的值
    *nonConstPtr = 55;

    // 输出修改后的值
    std::cout << "Modified value: " << nonConstValue << std::endl;

    return 0;
}

在修改之前，你需要确保指针所指的对象或引用被绑定的对象本身是可修改的！

使用const_cast的场景一般不能使用static_cast：

    int* nonConstPtr1 = const_cast<int*>(constPtr);
    //int* nonConstPtr2 = static_cast<int*>(constPtr); //编译错误：static_cast 无法丢掉常量或其他类型限定符

在使用 const_cast 进行类型转换时，尖括号中的类型必须符合以下要求：

  1. 转换方向匹配： 转换的方向应当是合法的。如果原始对象是 const 类型，那么 const_cast 的尖括号中的类型应当是非 const 类型。如果原始对象不是 const 类型，那么 const_cast 的尖括号中的类型应当是 const 类型。
    例如，如果有一个 const int* 类型的指针，你可以使用 const_cast<int*>(constIntPtr) 来将其转换为 int* 类型。

实际上不管怎么修改，都是符合语法的，不会报错：

int Value = 42;

// 四种指针
int* int_Ptr = &Value;
const int* const_int_Ptr = &Value;
int const* int_const_Ptr = &Value;
const int* const const_int_const_Ptr = &Value;

// 使用 const_cast 修改 const 属性

// 1. int* -> int*
int* Ptr1 = const_cast<int*>(int_Ptr);

// 2. int* -> const int*
const int* Ptr2 = const_cast<const int*>(int_Ptr);

// 3. const int* -> int*
int* Ptr3 = const_cast<int*>(const_int_Ptr);

// 4. const int* -> const int*
const int* Ptr4 = const_cast<const int*>(const_int_Ptr);

// 5. int const* -> int*
int* Ptr5 = const_cast<int*>(int_const_Ptr);

// 6. int const* -> const int*
const int* Ptr6 = const_cast<const int*>(int_const_Ptr);

// 7. const int* const -> int*
int* Ptr7 = const_cast<int*>(const_int_const_Ptr);

// 8. const int* const -> const int*
const int* Ptr8 = const_cast<const int*>(const_int_const_Ptr);

// 9. int* const -> int*
int* Ptr9 = const_cast<int*>(int_const_Ptr);

// 10. int* const -> const int*
const int* Ptr10 = const_cast<const int*>(int_const_Ptr);

// 11. const int* const -> int* const
int* const Ptr11 = const_cast<int* const>(const_int_const_Ptr);

// 12. const int* const -> const int* const
const int* const Ptr12 = const_cast<const int* const>(const_int_const_Ptr);

// 13. const int* const -> int const*
int const* Ptr13 = const_cast<int const*>(const_int_const_Ptr);

// 14. const int* const -> const int const*
const int const* Ptr14 = const_cast<const int const*>(const_int_const_Ptr);

// 15. int const* const -> int*
int* Ptr15 = const_cast<int*>(int_const_Ptr);

// 16. int const* const -> const int*
const int* Ptr16 = const_cast<const int*>(int_const_Ptr);
  1. 底层类型匹配： 尖括号中的类型必须是原始类型的底层类型。底层类型是指指针或引用所指向的实际类型。
    例如，如果有一个 const int* 类型的指针，使用 const_cast<double*>(constIntPtr) 来将其转换为 double* 类型是不合法的，因为 int 和 double 不是相同的底层类型：
const int value = 42;
const int* ptr = &value;
int* ptr2 = const_cast<double*>(ptr); // 编译错误

请添加图片描述

3. reinterpret_cast

reinterpret—cast 通常为运算对象的位模式提供较低层次上的重新解释。举个例子，假设有如下的转换：

int a = 123;
int* ip = &a;
char* pc1 = reinterpret_cast<char*>(ip);
char* pc2 = static_cast<char*>(ip);     //这里使用static_cast会报错：类型转化无效
char* pc3 = const_cast<char*>(ip);      //const_cast不能修改基础类型

我们必须牢记 pc 所指的真实对象是一个 int 而非字符，如果把 pc 当成普通的字符指针使用就可能在运行时发生错误。例如：

cout << pc << endl;

可能导致异常的运行时行为。

用reinterpret_cast强转测试平台大小端

大端存储模式：是指把数据的低位保存在内存的高地址中，把数据的高位，保存在内存的低地址中；
小端存储模式：是指把数据的低位保存在内存的低地址中，把数据的高位，保存在内存的高地址中。

#include \<iostream>

int main() 
{
   int intValue = 0x12345678;

   // 使用 reinterpret_cast 将 int* 转化为 char*
   char* charPtr = reinterpret_cast<char*>(&intValue);

   // 输出每个字节的十六进制表示
   std::cout << "Memory content: ";
   for (int i = 0; i < sizeof(int); ++i) 
   {
       std::cout << std::hex << static_cast\<int>(charPtr[i]) << " ";
   }
   std::cout << std::endl;

   // 判断平台是大端还是小端
   if (charPtr[0] == 0x78) 
   {
       std::cout << "该平台是小端" << std::endl;
   }
   else if (charPtr[sizeof(int) - 1] == 0x78) 
   {
       std::cout << "该平台是大端" << std::endl;
   }
   else 
   {
       std::cout << "大小端未知" << std::endl;
   }

   return 0;
}

4. dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用（动态转换）。
使用形式如下所示：

dynamic_cast<type*>(e)
dynamic_cast<type&>(e)
dynamic_cast<type&&>(e)

其中:

  • e必须是一个类类型，并且通常情况下该类型应该含有虚函数。
  • 在第一种形式中，e 必须是一个有效的指针；
  • 在第二种形式中，e 必须是一个左值；
  • 在第三种形式中，e 不能是左值。

在上面的所有形式中， e 的类型必须符合以下三个条件中的任意一个：

  • e 的类型是目标 type 的公有派生类
  • e 的类型是目标 type 的公有基类
  • e 的类型就是目标 type 的类型

如果符合，且基类指针/引用指向的实际对象是派生类对象时，类型转换可以成功。否则，转换失败：

  • 如果一条 dynamic_cast语句的转换目标是指针类型并且失败了，则结果为 0 。
  • 如果转换目标是引用类型并且失败了，则 dynamic_cast 运算符将抛出一个 bad_cast 异常。

验证一下：

#include <iostream>
#include <typeinfo>

class A
{
public:
    virtual void f() {}
};

class B : public A
{
    virtual void f() override {}
};

int main()
{
    A a;
    B b;


    // 子类对象指针/引用 -> 父类指针/引用
    // dynamic_cast<type*>(e)
    A* ptrA = dynamic_cast<A*>(&b);
    if (ptrA) 
    {
        std::cout << "从B*到A*的动态转换成功。" << std::endl;
    }
    else 
    {
        std::cout << "从B*到A*的动态转换失败。" << std::endl;
    }

    // dynamic_cast<type&>(e)
    try 
    {
        A& refA = dynamic_cast<A&>(b);
        std::cout << "从B&到A&的动态转换成功。" << std::endl;
    }
    catch (const std::bad_cast& e) 
    {
        std::cout << "从B&到A&的动态转换失败。" << std::endl;
    }

    // dynamic_cast<type&&>(e) - 注意：这种用法不常见，通常情况下我们不会将右值引用作为 dynamic_cast 的目标
    try 
    {
        A&& rrefA = dynamic_cast<A&&>(std::move(b));
        std::cout << "从B&&到A&&的动态转换成功。" << std::endl;
    }
    catch (const std::bad_cast& e) 
    {
        std::cout << "从B&&到A&&的动态转换失败。" << std::endl;
    }

    // 父类对象指针/引用 -> 子类指针/引用
    // dynamic_cast<type*>(e)
    B* ptrB = dynamic_cast<B*>(&a);
    if (ptrB)
    {
        std::cout << "从A*到B*的动态转换成功。" << std::endl;
    }
    else 
    {
        std::cout << "从A*到B*的动态转换失败。" << std::endl;
    }

    // dynamic_cast<type&>(e)
    try
    {
        B& refB = dynamic_cast<B&>(a);
        std::cout << "从A&到B&的动态转换成功。" << std::endl;
    }
    catch (const std::bad_cast& e)
    {
        std::cout << "从A&到B&的动态转换失败。" << std::endl;
    }

    // dynamic_cast<type&&>(e)
    try
    {
        B&& rrefB = dynamic_cast<B&&>(std::move(a));
        std::cout << "从A&&到B&&的动态转换成功。" << std::endl;
    }
    catch (const std::bad_cast& e)
    {
        std::cout << "从A&&到B&&的动态转换失败。" << std::endl;
    }


    return 0;
}

请添加图片描述

后面三个失败的原因是括号中的指针或引用的实际指向的对象不是派生类对象，语法只允许一个动态类型是派生类指针的对象的静态类型从基类指针转化为派生类指针！

注意：

  1. dynamic_cast只能用于父类含有虚函数的类
  2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0

向上转型：子类对象指针/引用 -> 父类指针/引用（不需要转换，因为有“赋值兼容规则”）
向下转型：父类对象指针/引用 -> 子类指针/引用（直接赋值不可以，但是用dynamic_cast转是安全的，因为有异常会抛异常或者返回空指针）


应该避免使用强制类型转换

强制类型转换关闭或挂起了正常的类型检查，每次使用强制类型转换前，程序员应该仔细考虑是
否还有其他不同的方法达到同一目的，如果非强制类型转换不可，则应限制强制转换值的作用
域，以减少发生错误的机会。

强烈建议：避免使用强制类型转换


四、RTTI - 运行时类型识别

RTTI：Run-time Type identification 的简称，即：运行时类型识别。

C++通过以下方式来支持RTTI：

  1. typeid运算符
  2. dynamic_cast运算符
  3. decltype

typeid 运算符：

typeid 运算符是C++中的运算符，用于获取表达式的类型信息。它返回一个std::type_info 对象，该对象包含有关表达式类型的信息。主要用于在运行时获取对象的实际类型，特别是在处理多态类型时。

type_info 类必须定义在 <typeinfo> 头文件中，并且至少提供下表所列的操作：

type_info的操作描述
t1 == t2如果 type_info 对象 t1 和 t2 表示同一种类型，返回 true，否则返回false
t1 != t2如果 type_info 对象 t1 和 t2 表示不同的类型，返回 true，否则返回false
t.name()返回一个 C 风格字符串，表示类型名字的可打印形式。
t1.before(t2)返回一个 bool 值，表示t1是否位于t2之前。

除此之外，因为 type_info 类一般是作为一个基类出现，所以它还应该提供一个公有的虚析构函数。当编译器希望提供额外的类型信息时，通常在 type_info 的派生类中完成。type_info 类没有默认构造函数，而且它的拷贝和移动构造函数以及赋值运算符都被定义成删除的。因此，我们无法定义或拷贝 type_info类型的对象，也不能为 type_info 类型的对象赋值。创建 type_info 对象的唯一途径是使用 typeid 运算符。

示例代码：

#include <iostream>
#include <typeinfo>

class Base 
{
public:
    virtual ~Base() {}
};

class Derived : public Base {};

int main() 
{
    Base* basePtr = new Derived();

    // 使用 typeid 获取对象的类型信息
    const std::type_info& typeInfo = typeid(*basePtr);

    // 比较类型信息
    if (typeInfo == typeid(Derived)) 
    {
        std::cout << "basePtr 指向 Derived 类型的对象。" << std::endl;
    } else if (typeInfo == typeid(Base)) 
    {
        std::cout << "basePtr 指向 Base 类型的对象。" << std::endl;
    }

    delete basePtr;

    return 0;
}

由运行结果可见，typeid 运算符获取到的类型名是运行时的动态类型：
请添加图片描述

dynamic_cast运算符

上文已经介绍

decltype关键字

decltype 是C++11引入的关键字，用于获取表达式的类型而不进行实际的计算。它在编译时返回表达式的类型，并常用于模板元编程和泛型编程中，以提取变量或表达式的类型。

示例代码：

// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
	decltype(t1 * t2) ret;
	cout << typeid(ret).name() << endl;
}

int main()
{
	const int x = 1;
	double y = 2.2;
	decltype(x * y) ret; // ret的类型是double
	decltype(&x) p; // p的类型是int*
	cout << typeid(ret).name() << endl;
	cout << typeid(p).name() << endl;
	F(1, 'a');
	return 0;
}

请添加图片描述

_宁清
关注
专栏目录
C语言隐式/显式类型转换 | C++四种强制类型转换、类的隐式转换、explicit
Jormungand_V的博客
02-04 2435
文章目录何时发生隐式类型转换 何时发生隐式类型转换 在大多数表达式中，比int类型小的整数值提升为较大的整数类型 在条件中，非布尔值转换成布尔类型 初始化过程中，初始值转换成变量的类型；在赋值语句中，右侧运算对象转化成左侧运算对象的类型 算术运算或关系运算对象有多种类型，需要转换成同一种类型 函数调用时也会发生类型转换 ...
类型转换—c、c++总结
Markdown
05-14 860
什么是隐式类型转换？什么时候会发生？那些类型可以隐式转换？强制类型转换什么情况必须用？c++与类型转换的4种关键字分别是什么，有什么区别和联系，各在什么场合下使用？等。 本文针对以上问题做简要小结。 同时会涉及到以下内容： 关于printf输出格式与类型不一致，请查看《%d输出float类型，%f输出int类型》 关于符号扩展，有符号与无符号的转换问题，请查看《符号位扩展，空间不足—char和int举例》
C/C++的类型转换
yin_ming_hui的博客
10-11 1640
因为要兼容C语言的类型转换，所以C++ 当中的类型转换最多只是一个建议，不强制使用，但在很多公司中会明确说明要使用C++当中的类型转换来进行规范书写和避免错误。我们在平时写代码的时候，也尽量使用C++当中的类型转换，养成良好习惯。
C/C++类型转换
zdaiot的博客
10-15 920
强制类型转换、使用函数转换与memcpy 如果一个int型的变量值为5，则若使用强制类型转换或者使用memcpy，则相当于直接copy内存中的值，若打印，则会打印5对应的ASCII值；而若使用函数转换，则函数会操作内存转为ASCII值的5，若打印，则直接为5。 memcpy在一定程度上相当于强制类型转换，但是可以制定拷贝的字节大小，因此可能不会出现丢失数据，如大于256的时候，int强制转char...
c++与c的数据类型转换
weixin_43293737的博客
01-30 325
C风格的强制类型转换(Type Cast)很简单，不管什么类型的转换统统是： TYPE b = (TYPE)a C++风格的类型转换提供了4种类型转换操作符来应对不同场合的应用。 　static_cast 静态类型转换 如int转换成char reinterpreter_cast 重新解释类型 （强制转换类型） dynamic_cast 动态类型转换 如子...
一个c++转c的工具（cfront源码）
01-14
一个c++转c的工具（cfront源码），很好的工具源代码。满足特殊人使用。
c语言const类型强制转换,关于C++的强制类型转换浅析
weixin_34062155的博客
05-20 1569
前言一说起强制类型转换大家都很熟悉，相信很多学习完C++的朋友还在使用C语言的强制类型的方式 (类型)变量.C++其实也具有自己的一套强制类型转换它们分明是：static_cast reinterpret_cast const_cast dynamic_cast四种类型.那么肯定会有人好奇C++是不是闲，C语言的强制类型用的舒舒服服的，为什么要新推出来这几个?新类型的强制转换可以提供更好的控...
C语言和C++的优质项目源码.zip
10-18
- **变量与数据类型**：C语言支持基本的数据类型，如int、float、char等，以及复合类型如数组和结构体。 - **运算符与表达式**：包括算术运算符、关系运算符、逻辑运算符等，理解它们的优先级和结合性至关重要。 ...
关于C语言和C++的详细解释.zip
06-25
C语言和C++是两种广泛使用的编程语言，它们在计算机科学和软件开发领域扮演着重要角色。虽然C语言是C++的基础，但两者之间存在显著的差异和扩展特性。 C语言，由Dennis Ritchie在1972年创建，是一种中级语言，它...
C语言类型转换-自动类型转换、强制类型转换、指针类型转换
09-30
在C语言中，类型转换是编程过程中的重要概念，它涉及到数据类型的相互转换，以便在不同数据类型之间进行运算或赋值。本篇文章将详细探讨C语言中的三种主要类型转换：自动类型转换、强制类型转换以及指针类型的转换。...
C语言注释与C++注释的相互转换
ljx_5489464的博客
03-09 1900
做此项目的经历主要的收获是熟悉了状态机这一方法的使用，还有就是对每实现一个功能就尽量封装一个函数这一概念把握的更为精到。状态机：关于状态机的一个极度确切的描述是它是一个有向图形，由一组节点和一组相应的转移函数组成。状态机通过响应一系列事件而“运行”。每个事件都在属于“当前” 节点的转移函数的控制范围内，其中函数的范围是节点的一个子集。函数返回“下一个”（也许是同一个）节点。这些节点中至少有一个必须是
c到c++转换（二）
sansan的博客
10-03 1950
我是一个正在学习C++的同学，把自己的学习笔记和一些自己的理解记录下来。如果有什么地方写得不对，还希望各位朋友指正。我写的是有c语言基础之后学习C++ 的学习经历。并不是零基础学习C++。 5.字符串 c语言里面是没有字符串变量的，是通过字符数组来表示的。而且c语言里面的字符串有两大标识。1，字符串首地址 2，结束标志‘\0’。这里我们称它为c风格字符串。首先我们回忆一波C风格字符串有些什么处...
C语言与C++语言转换
FLYOU_U的博客
11-25 440
int a = 1;int a = 3;return 0;return 0;
C语言转c++
最新发布
ning6emma的博客
03-13 1200
C语言转c++，快速全面学习
超详细C转C++简单教程(算法竞赛所需)
wfuzhuandaaliu的博客
01-18 1万+
说实话，用c语言来写算法竞赛(蓝桥杯，acm)也是完全没有问题的，说是转型c++，其实并不是，只是借助了c++的一些STL容器(听起来很高级，其实就是栈，队列啥的)和一些库函数，例如sort函数，比快速排序啥的都要快，c++只需要一行就搞定了，不用再像c语言一样写很多，并不是真正的转型，也没必要担心自己学不会，还是c语言那老一套，只不过scanf printf换成cin cout等等。不过，用c++来写，确实省时省劲，还是很值得去学的！ 有很多教程和视频都做得十分晦涩难懂，生怕你学会了…所以我今天来做个简单
C语言转换成C++语言时，强制转换的意义和实现
XRay_XQ的博客
06-19 1130
强制转换为了匹配不同的数据类型以实现相应的代码功能。如下所示的强制转换例子：struct student *st = (struct student *) malloc(sizeof(struct student));(struct student *) 这个就是强制转换符，因为等号的左边是自己定义的一个struct 类的量student，右边开辟了一个堆空间，但是注意malloc返回值是一个vo...
c++类型转换
热门推荐
一条二哈
05-29 2万+
类型转换有 c 风格的,当然还有 c++风格的。c 风格的转换的格式很简单(TYPE) EXPRESSION,但是 c 风格的类型转换有不少的缺点,有的时候用 c 风格的转换是不合 适的,因为它可以在任意类型之间转换,比如你可以把一个指向 const 对象的指针转换 成指向非 const 对象的指针,把一个指向基类对象的指针转换成指向一个派生类对象的 指针,这两种转换之间的差别...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_宁清

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值