Question

嗯，这个问题的正确标题应该是“循环依赖类，哪些实例可以相互初始化”。

我有两个类（带有整数数据字段的Index3i和带有浮点数据字段的Index3f），它们可以相互“转换”，反之亦然：

文件“Index3i.h”：

here is the Code:


    public class MagicSquares {


public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    ArrayList<Integer> ints = new ArrayList<Integer>();
    int current = 0;
    do{
        System.out.print("Enter an int. Enter -1 when done>");
        current = Integer.parseInt(in.nextLine());
    }while(current != -1);
    int numInputs = ints.size();
    int square = (int) Math.sqrt(numInputs);

    if(square*square == numInputs){
        int[][] intSquare = new int[square][square];
        int x = 0;
        while(x < numInputs){
            for(int y = 0; y < square; ++y){
                for(int z = 0; z < square; ++z){
                    intSquare[y][z] = ints.get(x);
                    ++x;
                }
            }
        }
        if(isMagicSquare(intSquare)){
            System.out.println("You entered a magic square");
        }else{
            System.out.println("You did not enter a magic square");
        }

    }else{
        System.out.println("You did not enter a magic square. " +
                "You did not even enter a square...");
    }
}


private static Boolean isMagicSquare(int[][] array){
    int side = array.length;
    int magicNum = 0;
    for(int x = 0; x < side; ++x){
        magicNum =+ array[0][x];
    }
    int sumX = 0;
    int sumY = 0;
    int sumD = 0;
    for(int x = 0; x > side; ++x){
        for (int y = 0; y < side; ++y){
            sumX =+ array[x][y];
            sumY =+ array[y][x];
        }
        sumD =+ array[x][x];
        if(sumX != magicNum  || sumY != magicNum || sumD != magicNum){
            return false;
        }
    }
    return true;
}



}

文件“Index3f.h”：

// #include "Index3f.h"

class Index3i {
public:
    Index3i()
    : r(0), g(0), b(0) { }

    Index3i(const Index3i& copy)
    : r(copy.r), g(copy.g), b(copy.b) { }

    // Index3i(const Index3f& copy)
    // : r((int)copy.r), g((int)copy.g), b((int)copy.b) { }

    // Index3f toIndex3f() { ... }

    ...
};

我需要// #include "Index3i.h" class Index3f { public: Index3f() : r(0.0f), g(0.0f), b(0.0f) { } Index3f(const Index3f& copy) : r(copy.r), g(copy.g), b(copy.b) { } // Index3f(const Index3i& copy) // : r((float)copy.r), g((float)copy.g), b((float)copy.b) { } // Index3i toIndex3i() { ... } ... };类的对象能够初始化并转换为Index3i类的对象，反之亦然。另外，我想仅保留这些类标题。

好吧，如果我尝试取消注释已注释的构造函数，方法和包含这会产生循环依赖性问题。另一种可能的解决方案是实现一些转换函数，并将它们放在第三个包含文件中，如“IndexConvert.h”左右。

但也许有其他方法？能否请您为此案建议一个合适的解决方案？

Answer 1

让它们成为单个类模板 - 听起来你实际上并不需要开始使用两个不同的类。这样，您就可以编写转换构造函数模板：

template <class T>
class Index3 {
    T r, g, b;

public:
    Index3() : r(0), g(0), b(0) { }
    Index3(const Index3&) = default;

    template <class U, class = std::enable_if_t<std::is_convertible<U, T>::value>>
    Index3(const Index3<U>& rhs)
    : r(rhs.r), g(rhs.g), b(rhs.b)
    { }

    /* rest */
};

与可以相互初始化的类的循环依赖关系

1 个答案: