Question

可能是个愚蠢的问题，但我想初始化我的对象数组：

int N = 5+1;
int** tab = new int*[N];
for (int n = 0; n < N; n++) {
    tab[n] = new int[N];
    for (int k = 0; k < N; k++) {
        tab[n][k] = 0;
    }
}
tab[1][1] = 1;
for (int n = 2; n < N; n++) {
    for (int k = 1; k <= n; k++) {
        if (n % 2 == 0) {
            for (int j = 0; j < k; j++) {
                tab[n][k] += tab[n-1][j];
            }
        }
        else {
            for (int j = k; j < n; j++) {
                tab[n][k] += tab[n-1][j];
            }
        }
    }
}
int res = 0;

for (int j = 0; j < N; j++) {
    res += tab[N - 1][j];
}

FooBar在哪里：

FooBar[] fooBars = new FooBars[]
{
    {"Foo", "Bar"},
    {"Foo", "Bar"}
};

我尝试从CollectionBase继承并添加Add（string）方法或string []运算符，但这些都不起作用：/

Answer 1

这是你在找什么？我不明白你在问什么。

如果您愿意，可以在此fiddle中播放一下。

public class FooBar
{
    public FooBar(string foo, string bar)
    {
        this.foo = foo;
        this.bar = bar;
    }

    public string foo;
    public string bar;
}

public static void Main(String[] args)
{
    FooBar[] fooBars = new FooBar[] {
        new FooBar("Foo", "Bar"), 
        new FooBar("Foo", "Bar")
    };
}

Answer 2

你可以通过给类FooBar一个隐式构造函数来欺骗（需要最新版本的C＃用于元组支持）：

public class FooBar
{
    public string foo;
    public string bar;

    public static implicit operator FooBar((string, string) init)
    {
        return new FooBar{ foo = init.Item1, bar = init.Item2 };
    }
}

然后像这样的代码将起作用：

var fooBars = new FooBar[]
{
    ("Foo1", "Bar1"),
    ("Foo2", "Bar2")
};

OR

FooBar[] fooBars = 
{
    ("Foo1", "Bar1"),
    ("Foo2", "Bar2")
};

然后：

foreach (var fooBar in fooBars)
    Console.WriteLine($"foo = {fooBar.foo}, bar = {fooBar.bar} ");

这似乎与你的目标非常接近（尽管有括号而不是括号）。

但通常您只是根据其他答案使用new FooBar("Foo", "Bar")语法。

像初始化类C＃的数组

2 个答案: