Question

我几乎可以肯定这不可能做到，但无论如何我都会问。我必须使用基于C的库，它将数字向量定义为浮点数组，并使用许多算术函数。我想创建一个可以轻松转换为该类型的普通类，并添加有用的运算符。让我们看一下MWE：

#include <iostream>

using vector_type = float[3];

class NewType
{
public:
    float& operator [](std::size_t i) { return v[i]; }
    const float& operator [](std::size_t i) const { return v[i]; }

    operator vector_type& () { return v; }
    vector_type* operator & () { return &v; }

private:
    vector_type v;
};

int main()
{
    NewType t;
    t[0] = 0.f; t[1] = 1.f; t[2] = 2.f;

    const vector_type& v = t;
    std::cout << "v(" << v[0] << "," << v[1] << "," << v[2] << ")" << std::endl;

    return 0;
}

这完美无瑕。当我们开始使用数组时会出现问题。让我们写一个新的主要功能：

int main()
{
    constexpr std::size_t size = 10;
    vector_type v1[size];                   // OK
    NewType v2[size];                       // OK
    vector_type* v3 = v2;                   // No way, NewType* cannot be
                                            // converted to float (*)[3]
    vector_type* v4 =
        reinterpret_cast<vector_type*>(v2); // OK

    return 0;
}

reinterpret_cast有效，但它使代码的可读性降低，vector_type和NewType之间的转换不透明。据我所知，根据C ++ 11和C ++ 14标准，在使用数组时隐藏 castable 的NewType类是不可能的。这完全是真的吗？是否有任何允许这种转换的警告？

Ps：请不要开始评论使用reinterpret_cast等风险。我知道风险，我知道编译器可以添加一些填充，我已经有了一些static_assert检查以避免内存问题。

[编辑]我想让问题更容易理解。让我们做一个不同的例子：

struct original_vector
{
    float x;
    float y;
    float z;
};

class NewType : public original_vector
{
public:
    /* Useful functions here */
};

如果这是我的情况，一切都会很容易！ C库中使用的类型是original_vector，我可以创建一个派生类，我可以添加任何类型的方法。

问题在于，在我的实际情况中，original_vector 不是类/结构，而是原始数组！显然，我不能继承它。也许现在我更清楚我问这个问题的原因。 ;）

Answer 1

我认为它不是最好的解决方案，但它是我能想到的最好的C ++ 14功能。也许，如果在未来的标准中引入了运行时大小的成员分配（C ++ 14的提案已经被拒绝），那么更好的解决方案将成为可能。但是现在......

#include <iostream>
#include <memory>
#include <cassert>

using vector_type = float[3];

class NewType
{
public:
    float& operator [](std::size_t i) { return v[i]; }
    const float& operator [](std::size_t i) const { return v[i]; }

    operator vector_type&  () { return v; }
    vector_type* operator & () { return &v; }

private:
    vector_type v;
};

class NewTypeArray
{
public:
    NewTypeArray() : size(0), newType(nullptr) {}
    NewTypeArray(std::size_t size) : size(size) { assert(size > 0); newType = new NewType[size]; }
    ~NewTypeArray() { if(size > 0) delete[] newType; }

    NewType& operator[](std::size_t i) { return newType[i]; } 
    operator vector_type* () { return static_cast<vector_type*>(&newType[0]); }

private:
    std::size_t size;
    NewType* newType;
};

static_assert(sizeof(NewType) == sizeof(vector_type) and sizeof(NewType[7]) == sizeof(vector_type[7]),
    "NewType and vector_type have different memory layouts");

显然，可以修改NewTypeArray，实现面向向量的方法，移动构造函数和赋值（就像在我的实例代码中一样）。 NewTypeArray的实例可以直接传递给以vector_type*为参数的函数，并且由于static_assert，内存管理不应该出现任何问题。

Answer 2

import flash.media.SoundMixer;
import flash.media.SoundTransform;

// volume limits are 0 to 1 (0.1,0.2,0.3,...,1)
SoundMixer.soundTransform = new SoundTransform(0);

C ++中数组对象的隐式类型转换

2 个答案: