标签: static-cast

令我惊讶的是，gcc 11.2接受此代码，但仅在 C++20 模式下：

struct Base {};
struct Derived : Base { int i; };
int f(Base& b) { return static_cast<Derived>(b).i; }
//                                  ^~~~~~~ oops, forgot the `&`

同样，MSVC 19.29 在 C++20 模式下接受它，在 C++17 模式下拒绝它，但即使在 C++20 模式下，clang 也会拒绝它。

查看汇编器输出，f总是返回0，因此它忽略了Derived传递给的任何潜在的实际数据f。

这是 UB，还是在 C++20 中合法，如果是，为什么？

当我尝试使用static_cast将double*转换为int*时,我收到以下错误:

invalid static_cast from type ‘double*’ to type ‘int*’

这是代码:

#include <iostream>
int main()
{
        double* p = new double(2);
        int* r;

        r=static_cast<int*>(p);

        std::cout << *r << std::endl;
}

我理解在double和int之间转换会有问题,但为什么在double*和int*之间转换有问题？

我有一个T * pValues我想要查看的指针T (&values)[N]

在这个SO答案/sf/answers/184449611/中,建议的方法是

T (&values)[N] = *static_cast<T(*)[N]>(static_cast<void*>(pValues));

我对此的担忧是.在他的例子中,pValues以下面的方式初始化

T theValues[N];
T * pValues = theValues;

我的问题是,如果pValues来自以下任何构造,则构造构造是否合法:

1:

T theValues[N + M]; // M > 0
T * pValues = theValues;

2:

T * pValues = new T[N + M]; // M >= 0

简单的问题：从 int（例如 100）转换为双精度数“向上或向下舍入”到下一个双精度数，还是总是舍入到最接近的一个（最小增量）？

例如static_cast<double>(100)：

如果 d2 < d1 会向哪个方向投射？

额外问题：我可以以某种方式强制处理器使用特殊函数向下或向上“舍入”到双精度吗？据我所知，没有floor<double>或者ceil<double>不幸的是。

让我们有一个名为Y的函数重载:

void Y(int& lvalue)
{ cout << "lvalue!" << endl; }

void Y(int&& rvalue)
{ cout << "rvalue!" << endl; }

现在,让我们定义一个像std :: forward一样的模板函数

template<class T>
void f(T&& x)
{
   Y( static_cast<T&&>(x) );   // Using static_cast<T&&>(x) like in std::forward
}

现在看看main()

int main()
{
   int i = 10;

   f(i);       // lvalue >> T = int&
   f(10);      // rvalue >> T = int&&
}

正如预期的那样,输出是

lvalue!
rvalue!

现在回到模板功能f()并替换static_cast<T&&>(x)为static_cast<T>(x).让我们看看输出:

lvalue!
rvalue!

一样的!为什么？如果它们是相同的,那么为什么std::forward<>从返回一个投x来 …

我有一些像这样的代码

struct B
{
    B() {}
    B(int v) {}
};

struct A
{
    operator int() const { return 1; }
    operator B() const { return B(); }
};

int main()
{
    A a;
    static_cast<B>(a); // Error here
    a.operator B(); // This is OK
    return 0;
}

它会产生这样的编译错误:

main.cpp: In function ‘int main()’:
main.cpp:16:21: error: call of overloaded ‘B(A&)’ is ambiguous
     static_cast<B>(a);
                     ^
main.cpp:4:5: note: candidate: B::B(int)
     B(int v) {}
     ^
main.cpp:1:8: note: candidate: constexpr B::B(const B&)
 struct B
        ^
main.cpp:1:8: …