标签: static-cast

我正在编写代码,直到现在我正在使用这样的结构:

struct s{
  enum Types { zero = 0, one, two };
  unsigned int type;
  void* data;
} 

我需要一些通用的结构来存储来自不同类的数据,我想在std :: vector中使用它,这就是为什么我不能使用模板的原因.什么是更好的选择:工会或无效指针？

Void指针只分配我需要的空间,但是由于某些原因,c ++是强类型语言,并且我需要使用这些数据的地方不是c ++代码应该设计的方式.正如我所读到的,除非别无选择,否则不应使用void指针.

这个替代方案可能是工会.它们带有c ++,并为每个成员使用相同的内存空间,非常类似于void指针.然而,它们的价格是合理的 - 分配的空间是联合中最大元素的大小,在我看来,大小之间的差异很大.

这是相当风格和"正确的语言使用"问题,因为这两种方式完成了我需要做的事情,但我不能确定好的程式化的c ++代码是否可以为浪费的内存付出代价(尽管这些日子的内存不是很大)关心).

我正在创建一些旨在提供对回调功能的访问的接口.也就是说,继承自接口A允许类使用类型1的回调; 接口B允许类型2.继承A和B允许两种类型的回调.最终目的是A类和B类通过继承它们来处理所有脏工作.

第一个问题

这是一个小例子,应该说明我遇到的一些麻烦:

class A
{
public:
    static void AFoo( void* inst )
    {
        ((A*)inst)->ABar( );
    }
    virtual void ABar( void ) = 0;
};

class B
{
public:
    static void BFoo( void* inst )
    {
        ((B*)inst)->BBar( );
    }
    virtual void BBar( void ) = 0;
};

class C : public A, public B
{
public:
    void ABar( void ){ cout << "A"; };
    void BBar( void ){ cout << "B"; };
};

通过拨打电话

C* c_inst …

请遵守以下代码.据我所知,dynamic_cast比static_cast慢.因为它在运行时评估类型.我在这里的疑问是,如果我们将static_cast与typeid()一起使用如下,它是否需要与动态强制转换相同的时间？它会比dynamic_cast快吗？

class Shape
{ 
public:
  virtual ~Shape(){}
};
class Circle : public Shape{ };
class Square : public Shape{ };

使用RTTI进行静态转换:

Circle c;
Shape* s = &c; // Upcast: normal and OK

// More explicit but unnecessary:
s = static_cast<Shape*>(&c);
// (Since upcasting is such a safe and common
// operation, the cast becomes cluttering)

Circle* cp = 0;
Square* sp = 0;

// Static Navigation of class hierarchies
// requires extra type information:
if(typeid(s) == typeid(cp)) // C++ RTTI …

我是C++样式演员的新手,需要帮助理解下面的代码是如何工作的(这是我写的一些虚拟代码来理解事物).

#include <iostream>
#include <memory>

class A { 
public:
    A() : a(1) {
        std::cout << "Creating A\n";
    }   
    ~A() {
        std::cout << "Destroying A\n";
    }   
    int a;
};

class B : public A { 
public:
    B() : b(2) {
        std::cout << "Creating B\n";
    }   
    ~B() {
        std::cout << "Destroying B\n";
    }   
    int b;
};

int main() {
    std::shared_ptr<B> objectB(new B());
    {   
    std::shared_ptr<A> (static_cast<A*>(objectB.get()));
    std::cout << "End of inner scope\n";
    }   
    std::cout << "End of outer scope\n";
}

它打印

Creating A …

说我有以下类类型

class base
{

};

class der : public base
{
};

使用static_Cast,您可以使用对象和指针.

我试过以下 - 哪个有效(指针)

base* b = new base();
der * m = static_cast<der*>(b);

但是以下不起作用

base b;
der m = static_cast<der>(b);

有什么建议为什么第二个不起作用？静态转换不处理指针和对象吗？它适用于指针,但它不能与对象一起使用？

有一些函数将枚举作为参数

void myfunc(myEnum input);

据我了解，如果必须为此函数提供一个整数，建议将其显式转换为枚举，原因是所有整数可能都不是有效的枚举值。

根据MSDN

“ static_cast运算符可以将整数值显式转换为枚举类型。如果整数类型的值不在枚举值的范围内，则所得的枚举值不确定。”

并按照C ++标准5.2.9静态转换-> 10

“整数或枚举类型的值可以显式转换为枚举类型。如果原始值在枚举值（7.2）的范围内，则该值不变。否则，结果值未指定（并且可能不在该范围）。”

那么static_cast在这种情况下使用的意义是什么？是否有一些选项会引发超出枚举范围的值的异常（除了为此编写显式代码）？

static_cast工作怎么样？如果你做的事......

如果D通过某些未指定的层次结构(不一定是直接)从B继承,并且您执行以下操作:

B* b = new D();
D* d = static_cast<D*>(b);

怎么了？它只是在编译时计算偏移量并将该偏移量应用于指针吗？或者是否有一些事情在运行时发生以进行演员表？

我想知道我是否可以使用static_cast？将部分字符串转换为整数？我知道atoi()存在类似的东西,但我应该真的使用它才能将我的字符串的第一个字符转换为整数吗？

int w;
string my_str;
getline(cin, my_str);
w = static_cast<int>(my_str[0]) - 48;

这是正确的吗？或者我应该以另一种方式做到这一点？

在以下代码中:

    #include<iostream>
    using namespace std;
    int main()
    {
        const int i = 8;
        int j = 90;
        const_cast<int &>(i)  = 10;
        static_cast<const int&> (j);
        j = 200;
        cout << " i = " << i << endl;
        cout << " j = " << j << endl;
   }

我以为输出会是

i = 10
j = 90

但实际产量是

i = 8
j = 200 

所以铸造不起作用？

我正在关注一个教程，它说我可以使用静态强制转换将非const变量设为const。我尝试这样做，但编译器每次都会给我一个错误。

#include <iostream>
using namespace std;

int main()
{
int j = 0;
static_cast<const int&>(j) = 5 ;

cout << j;
return 0;
}

编译器给我以下错误消息。

hello.cpp: In function 'int main()':
hello.cpp:11:28: error: assignment of read-only location 'j'
 static_cast<const int&>(j) = 5 ;

然后，我尝试查看“ j”是否变为常数。但是我可以为此赋值，编译器在那里没有显示任何问题。由于前一行中的问题，可能是编译器未编译该行。

#include <iostream>
using namespace std;

int main()
{
int j = 0;
static_cast<const int&>(j) = 5 ;
j = 8;

cout << j;
return 0;
}

我已经搜索了很多解决方案，但没有找到任何解决方案。