C++ 什么'；s静态与静态之间的区别<；类型>；和静态_型<；类型*>；？

到目前为止，我了解到

static\u cast

是一种编译时操作，它以某种方式分析实体的内存，并尝试将其转换为指定的对象

我看到static_cast作为

static_cast

被广泛使用。这是什么原因？是因为编译器需要一个指针来检查对象的内存布局吗

例如：

union U { int a; double b; } u;
void* x = &u;                        // x's value is "pointer to u"
double* y = static_cast<double*>(x); // y's value is "pointer to u.b"
char* z = static_cast<char*>(x);     // z's value is "pointer to u"

联合U{int a；双b；}U； void*x=&u；//x的值是“指向u的指针” 双*y=静态_投射（x）；//y的值是“指向u.b的指针” char*z=static_cast（x）；//z的值是“指向u的指针” 但是，对于

static\u cast

这会失败：

double yy = static_cast<double>(u); error: cannot convert 'union U' to 'double' without a conversion operator

double yy=static_cast（u）；错误：在没有转换运算符的情况下，无法将“union U”转换为“double”

我首先在类的使用中发现了这种类型的强制转换，看起来在那里使用得更多

Derived * d = new Derived();
Base * b = static_cast<Base *>(d);

Derived*d=new-Derived（）；
底座*b=静态铸件（d）；

然而，同样的问题仍然存在：

Base b1 = Base();
Derived d2 = Derived();

b1 = static_cast<Base>(d2);
// No error here

Base b1=Base（）；
派生d2=派生（）；
b1=静态铸件（d2）；
//这里没有错误

我能否收到一份关于静态_cast如何在幕后工作的详细解释，以及它如何与内存（因此是对象）和（如有必要）发生的指令相关

static\u cast

和

static\u type

之间有什么区别

类型

和

类型*

是不同的类型。第一个强制转换转换为一种类型，第二个强制转换转换为另一种类型

我看到static_cast作为

static_cast

被广泛使用。这是什么原因

---

因为在这种情况下，意图是转换为类型<代码> t*<代码> .< /p> ，这可能有助于考虑两种不同的用例：StasyTysCase<代码>：一种用于将非指针类型转换为另一种类型，另一种用于将指针类型转换为另一种。 在将非指针类型相互转换时，

static\u cast

的含义是“执行从源值初始化目标类型对象时所执行的转换类型”。例如，在本代码中：

int aASCII = 64;
cout << static_cast<char>(aASCII) << endl; // Prints 'A'

int total = 137;
int numItems = 42;
cout << static_cast<double>(total) / numItems << endl;

同样，考虑这个代码：

int aASCII = 64;
cout << static_cast<char>(aASCII) << endl; // Prints 'A'

int total = 137;
int numItems = 42;
cout << static_cast<double>(total) / numItems << endl;

考虑到这一点，为什么这段代码不编译

double yy = static_cast<double>(u); // Oops!

在这里，这不会编译，因为您无法将

double

初始化为

union

类型

U

的变量

将

静态\u cast

与指针一起使用时使用了一组不同的规则。当使用指针时，

static\u cast

意味着“请假装指针指向我希望它指向的类型的对象，但前提是存在某种可行的情况。”例如，这是完全合法的：

Base* ptr = new Derived;
Derived* dPtr = static_cast<Derived*>(ptr);

这将不起作用，因为类型为

float*

的指针无法指向

派生的
对象（在某个时间点对某个指针不做任何可怕的事情）

您的代码

double* y = static_cast<double*>(x); // y's value is "pointer to u.b"

double*y=static_cast（x）；//y的值是“指向u.b的指针”

之所以好是因为
x
是一个
void*
，它可以指向任何（非功能）实体，所以它可以指向一个
双
不，
static\u cast
不“分析任何东西的内存”。就星号的意思而言，这意味着一个指针。完整而完整的讨论C++中的指针是非常容易的C++教材。这就是你要寻找的“详细解释”的地方。一旦你经历了这些，这种演员阵容的原因，在这里，应该更容易理解。否则，这个问题对于Stackoverflow来说太宽泛了。这是否回答了您的问题？在学习规范之前，努力理解“幕后”是什么，这是在倒退。除非您首先了解编译器试图产生的行为，否则您将无法理解编译器为什么要执行某些操作。它如何不执行？如果我理解正确的话，这与编译器对隐式转换的理解是一样的（如我所说）。关于我的问题，我想你没有意识到，从初学者的角度来看，指针和“静态施法”是两件完全不同的事情。多态性是使用静态类型转换的典型目的，2。多态性在实际应用中总是使用指向多态类的指针哈，太棒了！！！下列操作是否被视为相同<代码>无效*x=&u；双*d=重新解释铸件（&u）与相同<代码>双*w=静态_铸造（x）…（注意重新解释和静态）
float* ptr = new float[137];
Derived* dPtr = static_cast<Derived*>(ptr); // Error!

double* y = static_cast<double*>(x); // y's value is "pointer to u.b"