Question

我正在尝试使用枚举类型来索引某些数组，但我想根据某些选项允许不同的向量排序。在类中，我还想要将枚举变量作为输入并使用它的函数。

我找到的解决方案如下

#include<iostream>
#include<array>
#include<vector>

struct A{
  struct XYZ{
    enum coord{X=0,Y,Z};
  };
  struct YZX{
    enum coord{Y=0,Z,X};
  };
  struct ZXY{
    enum coord{Z=0,X,Y};
  };
  std::array<std::vector<float>,3> val;
  void resize(int opt, size_t dim){
    val[opt].resize(dim);
    return;
  }
  void printsize(){
    for(auto & i : val){
      std::cout << i.size() << " ";
    }
    std::cout << std::endl;
    return;
  }
};

int main(){
  A foo1;
  A foo2;
  A foo3;
  foo1.resize(XYZ::X,10);
  foo2.resize(YZX::X,10);
  foo3.resize(ZXY::X,10);
  std::cout << "Size foo1\n";
  foo1.printsize();
  std::cout << "Size foo2\n";
  foo2.printsize();
  std::cout << "Size foo3\n";
  foo3.printsize();
  return 0;
}

我在这个解决方案中不喜欢的是我的函数resize采用整数类型作为输入，并且没有枚举的类型控制。

还有其他更智能的解决方案吗？我在做一些被认为是反模式的事情吗？

谢谢

Answer 1

Index课怎么样，可以从几个enum class es？

构建

struct A
{
    enum class XYZ {X,Y,Z};
    enum class YZX {Y,Z,X};
    enum class ZXY {Z,X,Y};

    struct Index
    {
        int value;
        operator int() const {return value;}
        Index(XYZ value) : value(int(value)) {}
        Index(YZX value) : value(int(value)) {}
        Index(ZXY value) : value(int(value)) {}
    };

    std::array<std::vector<float>, 3> val;

    void resize(Index opt, size_t dim)
    {
        val[opt].resize(dim);
    }

    void printsize() const
    {
        for (const auto &i : val)
             std::cout << i.size() << ' ';
        std::cout << '\n';
    }
};

Answer 2

我建议您修改成员函数resize（三个参数而不是两个参数）并利用enum class es的类型安全性：

    #include <stdio.h>
    #include<iostream>
    #include<array>
    #include<vector>

    struct A{

        enum class Coordinate
        {
            X = 0,
            Y = 1,
            Z = 2
        };

        enum class Permutation
        {
            XYZ = 0,
            ZXY = 1,
            YZX = 2
        };

        std::array<std::vector<float>,3> val;


        /* resize takes three parameters now */
        void resize(Permutation p, Coordinate c, size_t dim)
        {

            int  index = ( static_cast<int>(p) + static_cast<int>(c) ) % 3 ;

            val[index].resize(dim);
            return;
        }

        void printsize(){
            for(auto & i : val){
                std::cout << i.size() << " ";
            }
            std::cout << std::endl;
            return;
        }
    };



int main()
{

    A foo1;
    A foo2;
    A foo3;
    foo1.resize(A::Permutation::XYZ, A::Coordinate::X,10); 
    foo2.resize(A::Permutation::YZX, A::Coordinate::X,10); 
    foo3.resize(A::Permutation::ZXY, A::Coordinate::X,10); 
    std::cout << "Size foo1\n";
    foo1.printsize();
    std::cout << "Size foo2\n";
    foo2.printsize();
    std::cout << "Size foo3\n";
    foo3.printsize();

    return 0;
}

使用枚举类型来管理存储顺序

2 个答案: