标签: static-cast

的背景:

我正在用C++构建一个物理引擎,它计算笛卡尔空间中n体系统的引力演化,然后将其转换为任何一组预定义的坐标系.最终目标是使起始坐标系任意(在坐标系'n'中计算而不是仅用笛卡尔坐标),但这是一个遥远的目标.

问题:

因为坐标系应该可以互换,所以我使笛卡尔坐标系扩展了一个基本坐标系:

class CoordMember {
}

class CoordState {
   public:
      /* methods to operate on members */

   protected:
      std::vector<CoordMember*> members;
}

class Particle : public CoordMember {
}

class CartState : public CoordState {
}

尝试创建指向类型std::vector<Particle*>的成员对象的类型指针时出现错误std::vector<CoordMember*>:

CartState* state = new CartState(/* initialization vars */);
std::vector<Particle*>* parts = static_cast< std::vector<Particle*>* >(&state->members);

编译器错误是:

error: static_cast from 'std::vector<CoordMember *> *' to 'std::vector<Particle *> *' is not allowed
error: no viable overloaded '='

我知道此时的事实是数据state->members都是类型的Particle*.我不知道要做什么才能使这个演员成为可能.有任何想法吗？ …

我有些不清楚的地方希望引起您的注意，请检查这些代码片段：

template< typename DerivedClass >
class construction_management
{
    city* this_city;
public:
    construction_management()
    {
        this_city = static_cast< city* >(this);
    }
    ~construction_management();
};

我故意删除了所有不必要的代码，请查看构造函数，它将“this”指针静态转换为“city”类型，其定义如下：

class city : public construction_management< city >
{

public:

public:
    city( const string& name, const string& owner );
};

该类故意为空，因为我认为它所包含的内容与此处无关。希望我无法 100% 理解这里发生的事情，g++ 4.7.2 在编译阶段不打印警告或错误，每当我使用“this_city”指针时，我都可以访问 city 的所有公共成员，对象本身看起来是一致的，因为所有变量都已正确初始化并且始终包含有效数据。

我想知道的是，如果我将 Construction_management 定义为普通的非模板类，为什么此代码不起作用？由于尝试从 const 转换为指向城市的非 const 指针，转换失败，为什么？

这是错误打印：

game.hpp: In constructor 'city_manager::construction_management::construction_management()':
game.hpp:164:41: error: invalid static_cast from type 'city_manager::construction_management* const' to type 'city_manager::city*'

如果 Construction_management 是一个模板，为什么还要工作呢？这是一种CRTP吗？

谢谢你们。

在下面的代码中,由于name()是虚拟的,我希望将调用派生结构的方法.相反,什么是写出来的是"A".为什么？

#include <iostream>
using namespace std;
struct A {
    virtual string name() { return "A"; }
};
struct B : A {
    string name() { return "B"; }
};
int main (int argc, char *argv[]) {
    B b;
    cout << static_cast<A>(b).name() << endl;
    return 0;
}

我正在创建一个简单的测试实体组件系统.我有一个基Component类与几个派生类.然后我有几个系统将一些逻辑应用于这些组件.

// Component.h
// ------------
class Component
{
public:
    Component();
    ~Component();
}


// ControlComponent.h
// -------------------
#include <string>
#include "Component.h"

class ControlComponent : public Component
{
public:
    std::string input = ""; // store simple input instruction
    ControlComponent();
    ~ControlComponent();
};


// ControlSystem.cpp
void ControlSystem::update(Entity* entity)
{
    vector<Component*>* components = entity->getComponents();

    for (Component* component : *components)
    {
        PositionComponent* pc = static_cast<PositionComponent*>(component);
        ControlComponent* cc = static_cast<ControlComponent*>(component);

        if (pc != nullptr && cc != nullptr)
        {
            std::cout << "Which direction would you …

我想使用static_cast将复杂的<short>转换为complex <double>.

将complex <int16_t>转换为complex <double>

我试图做同样的事情,但我需要使用static_cast.我无法使用该解决方案的原因是因为我使用的是在其cast()函数中使用static_cast的Eigen.有没有办法扩展static_cast的功能以这种方式转换？或者有没有办法扩展Eigen的cast()函数来处理这种转换？

这基本上就是我的尝试:

Eigen::Array<std::complex<short>, Eigen::Dynamic, 1> short_array;
Eigen::Array<std::complex<double>, Eigen::Dynamic, 1> double_array;
double_array = short_array.cast< std::complex<double> >();

我正在寻找为基于c的freeRtos实现c ++包装器.我找到了这个链接

它只是一小段代码,但内部有以下内容:

  static void taskfun(void* parm) {
    static_cast(parm)->task();
       :
  }

我一直认为static_cast需要<type>它.有人能解释一下这段代码对我有用吗？ - 我觉得我错过了一些基本的东西:o

对于这个问题，不涉及多态性，即不涉及虚方法，不涉及虚基类。以防万一，我的案子不涉及其中任何一个。

假设我有一个类Derived，它有一个明确的可访问父类型Base，没有多态性（没有虚拟方法，没有虚拟基类），但可能涉及间接和/或多继承。进一步假设我有一个有效的指针Derived *derived （指向类型Derived或其子类的对象）。

在这种情况下，我相信static_cast<Base*>(derived)是有效的（产生有效的可用指针）。Base当和之间的祖先链Derived涉及多重继承时，这static_cast可能意味着指针调整以在实例Base内定位实例Derived。为此，编译器需要知道继承链，在本例中他就是这样做的。但是，如果插入了中间转换void *，则编译器将隐藏该继承链信息。对于哪个继承链来说，这样的静态转换仍然有效？我期望以下之一：

• 一个都没有？访问static_castfrom void 指针是未定义的行为，除非该指针确实指向确切的类型。
• 对于所有没有多重继承的链？然后，编译器可以保证Base始终位于Derived- 但标准怎么说？
• 对于所有链，Base在所有中间多重继承链的第一个父类中可以找到什么？Base也许和的开始Derived仍然匹配？
• 总是？static_castto void 指针始终可以调整到第一个父级的开头，而static_castfrom void 指针则撤消该调整。但对于多重继承，“第一个父母”不一定是所有父母的父母。

我有用户定义的类型：

class String::CharProxy
{
public:
    const char* operator&() const;
    char* operator&();
    operator char() const;
    operator char&();
};

问题是当我尝试执行一些显式转换时，调用了错误的运算符：

CharProxy p(...);
static_cast<char>(p); // operator char&() call instead of operator char() const

我希望在投射到和-仅投射到时operator char() const被呼叫。charoperator char&()char&

谁能解释一下这个机制是如何运作的？我有什么地方弄错了吗？

我对理解下面的代码有一些问题.为什么我能调用c()函数？

#include <iostream>
#include <list>


using namespace std;

class A
{};

class B : public A
{
 public:
  void c() { cout << "c: B" << ++x << endl; }   
  int x;
};

int main(void) {
  class A *a = new A();
  static_cast<B*>(a)->c();

  return 0;
}

ouptut是:

constr A
c: B1

我是C++的新手,我不知道为什么这段代码的输出是8而不是8.25？

谁能解释为什么这段代码输出的int不是double？

谢谢 :)

#include "stdafx.h"
#include <iostream>


int main()
{

double x = 8.25;
    int y;
    y = x;

    double z = static_cast<double>(y);
    std::cout << z << std::endl;
return 0;
}