Question

我试图在C ++中实现一个递归结构，看起来应该是这样的：

typedef struct {
    static constexpr int foo() {
        return 1;
    }
    typedef struct {
        // not valid - I meant foo() from "type" not from "recursive_type"
        static constexpr int foo() {
            return 2 * foo(); 
        }
        // ? (there should be another recursive type here)
    } recursive_type;
} type;

这应该是这样的：

static_assert(type::foo() == 1, "Nope");
static_assert(type::recursive_type::foo() == 2, "Nope");
static_assert(type::recursive_type::recursive_type::foo() == 4, "Nope");

基本上 - 我希望recursive_type包含看起来与type完全相同的结构，但其foo()返回的值是type＆＃39; s {{1}的两倍}}。但正如我在评论中指出的那样，我的方法存在一些问题，遗憾的是它没有用。

这样的结构能否以某种方式在C ++中声明，或者可能不可能？

Answer 1

排序。这是在C ++中实现类型递归的方式。

template< int tag >
struct X
{
    static constexpr int foo() { return 2 * X<tag-1>::foo(); }
};

template< >
struct X<1>
{
    static constexpr int foo() { return 1; }
};

#include <iostream>
using namespace std;

int main()
{
    static_assert(X<1>::foo() == 1, "Nope");
    static_assert(X<2>::foo() == 2, "Nope");
    static_assert(X<3>::foo() == 4, "Nope");

    cout << X<10>::foo() << endl;
}

Answer 2

是的，借用Let_Me_Be，您可以获得您要求的行为：

template< int tag >
struct X
 {
    static constexpr int foo() { return 2 * X<tag-1>::foo(); }

     typedef X<tag+1> recursive_type;
};


template< >
struct X<0>
{
    static constexpr int foo() { return 1; }

    typedef X<1> recursive_type;
};

typedef X<0> type;

static_assert(type::foo() == 1, "Nope");
static_assert(type::recursive_type::foo() == 2, "Nope");
static_assert(type::recursive_type::recursive_type::foo() == 4, "Nope");

当然有奖励你可以用recursive_type代替X<n>进行深度递归使用......

C ++ - 递归结构 - 它可能吗？

2 个答案: