Инициализировать элемент вектора <vector <mytype>> в constrcutor

Question

У меня есть класс, членом которого является вектор векторов:

class binary_image_field_2d {
public:
    typedef double field_value_t;
    typedef vector<field_value_t> field_t;
protected:
    size_t _ndots;
    size_t _nfields;
    vector<field_t> _fields;
}

Я имею в виду конструктор, который может инициализировать на месте каждого из (внутренних) векторовс другим постоянным значением:

binary_image_field_2d(const size_t ndots, const size_t nfields, const vector<field_value_t> init_vals) : 
    _ndots(ndots), _nfields(nfields), 
    _fields( initialize here each element of _fields with a vector of
             constant value given by an element of init_vals ) {};

Например, если ndots=3, nfields=2 и init_vals={0.1, 1.0}, с

binary_image_field_2d img;

Я имею в виду получить

{{0.1, 0.1, 0.1}, {1.0, 1.0, 1.0}}

Как это должно быть написано (если вообще возможно)?

Answer 1

Вы можете сделать это используя приватную функцию в конструкторе:

#include <vector>
#include <iostream>
#include <cstdint>

class binary_image_field_2d
{
public:
    typedef double field_value_t;
    typedef std::vector<field_value_t> field_t;
    binary_image_field_2d(const size_t ndots, const size_t nfields, const std::vector<field_value_t> init_vals) : _ndots(ndots), _nfields(nfields),_fields(init_fields(ndots, nfields, init_vals))
    {// Empty constructor}

protected:
    size_t _ndots;
    size_t _nfields;
    std::vector<field_t> _fields;

private:
    std::vector<field_t> init_fields(const size_t ndots, const size_t nfields, const std::vector<field_value_t> init_vals)
    {
        std::vector<field_t> vec;
        for (int i = 0; i < nfields; ++i)
        {
            vec.emplace_back(std::vector(ndots, init_vals[i]));
        }
        return vec;
    }
public:
    void print_fields()
    {
        for (auto vec : _fields)
        {
            for (auto value : vec)
            {
                std::cout << value << " ";
            }
            std::cout << std::endl;
        }
    }
};

int main(void)
{
    binary_image_field_2d b(3, 2, {0.1f, 1.1f});
}

Вы также можете сделать это, используя лямбда-функцию вместо закрытой функции:

#include <vector>
#include <iostream>
#include <cstdint>

class binary_image_field_2d
{
public:
    typedef double field_value_t;
    typedef std::vector<field_value_t> field_t;
    binary_image_field_2d(const size_t ndots, const size_t nfields, const std::vector<field_value_t> init_vals) : _ndots(ndots), _nfields(nfields), 
    _fields([init_vals, nfields, ndots]() -> std::vector<field_t> {                                                                                                                      
        std::vector<field_t> vec;                                                                                                                      
        for (int i = 0; i < nfields; ++i)                                                                                                                      
        {                                                                                                                          
            vec.emplace_back(std::vector(ndots, init_vals[i]));                                                                                                                      
        }                                                                                                                          
        return vec;                                                                                                                  
    }())
    {// Empty constructor}

    void print_fields()
    {
        for (auto vec : _fields)
        {
            for (auto value : vec)
            {
                std::cout << value << " ";
            }
            std::cout << std::endl;
        }
    }    
protected:
    size_t _ndots;
    size_t _nfields;
    std::vector<field_t> _fields;
};

int main(void)
{
    binary_image_field_2d b(3, 2, {0.1f, 1.1f});
    b.print_fields();
}

в обоих случаях выход_программы будет:

0.1 0.1 0.1 
1.1 1.1 1.1