初始化對象數組中的向量大小

Question

我想初始化對象數組中向量的大小。

每個矢量具有相同的大小，以便...

LIB文件：

#include <vector> 

Class NameClass 
{ 
public: 
    explicit NameClass(unsigned size) 
    { 
    vectorName.resize(size); 
    } 

    std::vector <type> vectorName; 
}; 

主文件：

#include "lib.hpp" 

int main(void) 
{ 
    NameClass object(size); #1 

    NameClass object[ number_objects ](size); #2 
    NameClass object[ number_objects ] = {NameClass(size), NameClass(size), ... }; #3 

    return 0; 
} 

＃1的作品，而不是一個數組， ＃2沒有，編譯器說：「從int到非標量類型的轉換'NameClass'請求」 ＃3的作品，但是...它只是荒謬的初始化每個對象。而且我不能只在類中放入一個靜態的大小，因爲這個值會改變。

所以...我的研究說，我需要使用std :: generate。問題是......什麼是最好的方法？

對不起，如果很容易的問題如何使用std :: generate我是初學者，並找麻煩找到最佳的解決方案。

一些人認爲複雜的解決方案，但是，我一直用我的解決方案

#include "lib.hpp" 

int main(void) 
{ 
    unsigned number_objects = something; 
    unsigned size = other_thing; 
    NameClass object[ number_objects ]; 

    for(unsigned i = 0; i < number_objects; i++) 
    object[i].vectorName.resize(size); 

    return 0; 
} 

我使用變薄，因爲實在是容易理解，並工作。但我打開其他容易理解和功能解決方案。

link std::generate

Answer 1

如果使用的載體是沒有問題的，其實這作品，而且非常簡單。 這是一首詩......

類TEST.CPP

#include <stdio.h> 
#include <algorithm> 

#include "class.hpp" 

int main(void) 
{ 
    std::vector <NameClass> object(number_objects, NameClass(size)); 

    printf("%lu\n", object[0].vectorName.size()); 

    return 0; 
} 

class.hpp

#include <vector> 
#include <algorithm> 

#include <vector> 

class NameClass { 
public: 
NameClass() {} // default constructor 

explicit NameClass(unsigned size){ 
    vectorName.resize(size); 
} 
std::vector <double> vectorName; 
}; 

如果你想使用數組那麼就使用默認的構造函數。

clas.hpp

#include <vector> 

class NameClass { 
public: 
NameClass(unsigned size) { 
vectorName.resize(size); 
} // default constructor 

explicit NameClass(unsigned size){ // eliminate this 
    vectorName.resize(size); 
} 
std::vector <type> vectorName; 
}; 

類TEST.CPP

#include <stdio.h> 

#include "class.hpp" 

int main() { 
    NameClass objects[2](4); 

    printf("%lu\n", objects[0].vectorName.size()); 

    return 0; 
} 

此打印正確的輸出。

Answer 2

您必須初始化向量每次，它只是你如何在代碼中出示。你可以做這樣的事情

std::vector<NameClass> classes(number_of_objects); 
std::generate(classes.begin(), classes.end(), []{return NameClass(size);}); 

std :: generate將爲vector的每個元素初始化一個NameClass的實例。

Answer 3

如果您願意使用std::array和C++ 14，我們得到：

template<std::size_t...Is> 
auto index_over(std::index_sequence<Is...>) { 
    return [](auto&&f)->decltype(auto) { 
    return decltype(f)(f)(std::integral_constant<std::size_t, Is>{}...); 
    }; 
} 
template<std::size_t N> 
auto index_upto(std::integral_constant<std::size_t, N> ={}) { 
    return index_over(std::make_index_sequence<N>{}); 
} 

template<std::size_t N, class F, 
    class T = std::decay_t<std::result_of_t< F&(std::integral_constant<std::size_t, 0>&)>>, 
    class R = std::array<T, N> 
> 
R make_array(F&& f) { 
    return index_upto<N>()([&](auto...Is)->R { 
    return {{ f(Is)... }}; 
    }); 
} 

我們通過make_array<count>拉姆達。該lambda採用可轉換的參數 - 從編譯時間std::size_t的值爲I，並返回數組的第i個元素。

結果是大小爲count的std::array。

lambda可能需要auto I才能獲得編譯時多汁性，或者只需要std::size_t I即可獲取運行時版本的值。

以上大部分內容都可以轉換爲C++ 11，但它會變得很難看。我不喜歡醜陋的代碼。

Live example。

你的代碼是這樣：

int main(void) 
{ 
    unsigned size = 17; 
    constexpr std::size_t number_objects = 3; 

    auto objects = make_array<number_objects>([&](std::size_t){ return NameClass(size); }); 
} 

和objects現在是一個（std::）數組的長度number_objects的NameClass，所有大小size的。

Answer 4

爲你的類創建一個默認的構造函數：

#include <vector> 

class NameClass { 
public: 
NameClass() {} // default constructor 

explicit NameClass(unsigned size){ 
    vectorName.resize(size); 
} 
std::vector <type> vectorName; 
}; 

在主：

#include "lib.hpp" 

int main(void) 
{ 
    unsigned number_objects = something; 
    unsigned size = other_thing; 
    NameClass object[ number_objects ]; 

    for(unsigned i = 0; i < number_objects; i++) 
    object[i].vectorName.resize(size); 

    return 0; 
} 

原因例如2不工作是因爲C++沒有一個語法創建數組沒有提供默認構造函數的對象。

在蟒蛇它看起來像什麼：

[NameClass(size) for _ in range(number_objects)] 

我離題了。

要做到沒有默認的構造函數，仍然創造的，你可以使用這個列表（問題是，你爲什麼會想這樣做）：

#include <iostream> 

static constexpr unsigned NUM_OBJECTS = 10; 
static constexpr unsigned VEC_SIZE = 30; 

int main() { 
    NameClass *objects = static_cast<NameClass *>(operator new [](NUM_OBJECTS * sizeof *objects)); 

    for (unsigned i = 0; i < NUM_OBJECTS; i++) { 
     objects[i].vectorName.resize(VEC_SIZE); 
    } 

    // Required to free memory 
    operator delete[](objects); 

    return 0; 
}