在一行中初始化许多私有变量

我工作的遗留代码如下所示：在一行中初始化许多私有变量

class Foo { 
    public: 
    Foo(); 
    private: 
    bool a1, a2, a3 /*, ...*/, a50; 
}; 

Foo::Foo() { 
    a1 = a2 = a3 /* = ... */ = a50 = false; 
}

这是凌乱。有没有办法将同一时间的所有私有变量默认为与上述不同的单个值？我不想使用初始化列表，因为有太多变量。

我知道bool的默认构造函数赋值为false - 这可以利用吗？

来源

2015-10-07 erip

只是一个想法，而不必50级的bool为什么不'布尔标志[50] {FALSE}但是，'？ – NathanOliver

@NathanOliver我很乐意这样做，但是PM可能会争辩说，这些变量会失去一个有意义的标识符。 – erip

你可能想要做'memset（this，0，sizeof（Foo））'....即使它可能在你的具体示例中工作，那也不建议：http://stackoverflow.com/questions/1975916/should -c-programmer-avoid-memset – jpo38

class Foo 
{ 
private: 
    bool a1{}, a2{}, /*...,*/ a50{}; 
};

来源

2015-10-07 17:58:38 AlexD

尝试用这种

Foo::Foo (bool aa) : a1 (aa) , a2 (aa), a3 (aa),/*......*/a50(aa){}

来源

2015-10-07 18:11:28

这是怎么一点都不混乱？ –

有很多种可能的方式来做到这一点，但他们都非常相似。无论如何，你会用不同的形式分配你的变量。

我认为最好的主要方法是在您的构造函数中逐行分配所有变量。可能是其不够紧凑，但它是最有意义的，你永诺可以轻松看你的变量默认值：

Foo::Foo() { 
    a1 = false; 
    a2 = false; 
    /*...*/ 
    a50 = false; 
}

另一种方法是，你描述的，分配运营商：

Foo::Foo() { 
    a1 = a2 = a3 /* = ... */ = a50 = false; 
}

而另一个允许在构造函数声明后立即初始化变量：

Foo::Foo() : 
    a1(false), 
    a2(false), 
    /*...*/ 
    a50(true) 
    { }

如果我忘记了任何方法，请将它写入注释。

来源

2015-10-07 18:23:45 maxteneff

你没有提到使用数组''a [50] {false};' –

更清洁的解决方案，但是请阅读该问题的评论。在那里，作者说他对完全变量赋值有兴趣，而赋值名称有意义。因为我明白所选的变量名称。 – maxteneff

你可以有另一个类（在一个单独的头文件中），它看起来像下面这样。

class myBool { 
    public: 
    myBool(int x = 1) { _m = x; } 
    operator bool() const { return 0 < _m; } 
    private: 
    int _m; 
};

，并在您的文件，您可以添加以下

#include "myBool.h" 
#define bool myBool

这将初始化所有布尔的默认你myBool设定值。您可能需要向myBool类添加更多方法，以将其用作完整的数据类型。以上是解释答案的最低要求。

来源

2015-10-07 19:36:16 vikrant

以下是我迄今为止发布的其他解决方案，以防万一它对您有用。在它自己的结构

把你想要的数据质量，初始化为默认为false/0值：

struct MyData 
{ 
    bool a, b, c, d; 
    std::string e, f; 
};

现在继承这个结构（私人或其他），并明确在初始化它的构造函数的初始化列表：

class MyClass : private MyData 
{ 
public: 
    MyClass() 
     : MyData() 
    { 

    } 
};

这将所有的布尔变量为false，字符串是空的，任何整数变为0，指针变成空，等，等

如果您忘记将结构显式放入初始化列表中，则其某些成员可能未初始化。

来源

2015-10-07 19:45:51

确认，它总是需要更多的工作是在C++偷懒......

#include <iostream> 
#include <utility> 


template<class Tuple, std::size_t...Is> 
void zero_out_impl(Tuple& t, std::index_sequence<Is...>) 
{ 
    using expand = bool[]; 
    (void) expand { false, (std::get<Is>(t) = false)... }; 
} 

template<class...Args> 
void zero_out(std::tuple<Args...> t) 
{ 
    zero_out_impl(t, std::index_sequence_for<Args...>()); 
} 

struct lots_of_bools { 
    lots_of_bools() 
    { 
     zero_out(std::tie(a,b,c,d,e,f,g,h,i,j)); 
    } 
private: 

    bool a,b,c,d,e,f,g,h,i,j; 
}; 

auto main() -> int 
{ 
    lots_of_bools x; 
    return 0; 
}

来源

2015-10-07 20:51:21

不知道这比简单地将它们列在初始化列表中的工作少。 –

恰恰是我第一行的意思！ :) –

这里的另一种方式 - 包裹布尔的包装，默认构造它。

#include <iostream> 


struct auto_false 
{ 
    auto_false(bool initial = false) : value(initial) {}; 
    operator bool() const { return value; } 
    operator bool&() { return value; } 
private: 
    bool value; 
}; 

struct lots_of_bools { 
    lots_of_bools() 
    { 
    } 

    bool value_of_f() const { 
     return f; 
    } 

    void set_f(bool val) { 
     f = val; 
    } 

private: 

    auto_false a,b,c,d,e,f,g,h,i,j; 
}; 

using namespace std; 

auto main() -> int 
{ 
    lots_of_bools x; 
    cout << x.value_of_f() << endl; 
    x.set_f(true); 
    cout << x.value_of_f() << endl; 
    return 0; 
}

输出：

0 
1

来源

2015-10-07 20:57:40

在一行中初始化许多私有变量

回答

相关问题