C++ 是否可以在向量'；谁的构造函数？

是否有一种方法可以像使用

std:：for_each

那样使用lambda函数初始化某些容器的所有值？我需要一个随机

int

s的三维

std:：vector

，如果我可以在构造函数中这样做，而不必为每个

循环执行另一个
std:：for_，那就太好了

我尝试了以下方法，但未成功：

#include <iostream>     /* std::cout */
#include <vector>       /* std::vector */
#include <algorithm>    /* std::for_each */
#include <stdlib.h>     /* srand, rand */
#include <time.h>       /* time */



int main(){

    srand(time(nullptr));

    /* only initializes first element, count[0][0][0] */
    std::vector<std::vector<std::vector<int>>> count{100, 
        std::vector<std::vector<int>>{100, 
            std::vector<int>{100, 
            [](){
              return = rand() % 100; 
            }()
          }
       }
    };

    int temp = 0;

   /* here is how I access all elements using std::for_each and lambdas */
   std::for_each(std::begin(count), std::end(count), 
   [&temp](std::vector<std::vector<int>> i){
        std::for_each(std::begin(i), std::end(i), [&temp](std::vector<int> j){
            std::for_each(std::begin(j), std::end(j), [&temp](int k) {
                if(k > temp){
                    temp = k;
                }
            });
        });
    });

}

#include/*std:：cout*/
#include/*std:：vector*/
#包括/*标准：：每个*/
#包括/*srand，兰特*/
#包括/*时间*/
int main（）{
srand（时间（nullptr））；
/*仅初始化第一个元素，计数[0][0][0]*/
std：：向量计数{100，
std：：向量{100，
std：：向量{100，
[](){
return=rand（）%100；
}()
}
}
};
内部温度=0；
/*下面是如何使用std:：for_each和lambdas访问所有元素*/
标准：：对于每个（标准：：开始（计数），标准：：结束（计数），
[&temp]（标准：：向量i）{
标准：：对于每个（标准：：开始（i），标准：：结束（i），[&temp]（标准：：向量j）{
标准：：对于每个（标准：：开始（j），标准：：结束（j），[&temp]（int k）{
如果（k>温度）{
温度=k；
}
});
});
});
}

非常感谢任何帮助或想法
 最内层向量的元素都将根据调用lambda的结果进行初始化，即
rand（）%100
。它们都将被初始化为相同的值，并且无法在每次需要初始化元素（在您的示例中，是一个
int
）时调用lambda

如果您真的非常希望透明地实现这一点，您可以创建一种自己的类型，其行为与
int
完全相同，但以您想要的方式初始化默认值：

struct RandomInitInt
{
    RandomInitInt() { i = rand() % 100; }
    RandomInitInt(int i) : i(i) { }
    operator int () { return i; }
    int i;
};

然后您可以这样使用它：

std::vector<std::vector<std::vector<RandomInitInt>>> count(100,
    std::vector<std::vector<RandomInitInt>>(100,
        std::vector<RandomInitInt>(100)
      )
   );

std:：向量计数（100，
标准：：向量（100，
标准：：向量（100）
)
);

并将每次出现的
vector
替换为
vector

但是，只有当你绝望地想要消除这个循环时，才考虑这一点。就个人而言，我认为循环的存在更清楚地说明了向量的初始化方式——这意味着它更好地传达了您的意图。
因为在
向量的构造函数中调用lambda会将所有值初始化为相同的数（如前一个答案所述），我认为以下是将
int
s的3D
vector
初始化为
rand（）%100
的最佳方法：

srand(time(nullptr));
std::vector<std::vector<std::vector<int>>> count{100, std::vector<std::vector<int>>{100, std::vector<int>{100, 0}}};

for(auto& i : count){
    for(auto& j : i){
        for(auto& k : j){
            k = rand() % 100;
        }
    }
}

srand（时间（nullptr））；
std:：vector count{100，std:：vector{100，std:：vector{100，0}}；
用于（自动和输入：计数）{
对于（auto&j:i）{
用于（自动和k:j）{
k=rand（）%100；
}
}
}
感觉std:：generate/std:：generate\n就是你要找的东西
啊，这很有道理。我想我会在一个循环中初始化它。谢谢@user2052561:很高兴它有所帮助-至少部分如此：）