C++ 有没有办法在C+中将矩阵的所有元素设置为1+；？_C++_Matrix

C++ 有没有办法在C+中将矩阵的所有元素设置为1+；？

c++ matrix

C++ 有没有办法在C+中将矩阵的所有元素设置为1+；？,c++,matrix,C++,Matrix,假设我声明一个矩阵，如下-->long long int a[100][100]。在声明矩阵时，有没有办法将值1分配给它的所有元素？您可以使用fill\n方法并像这样初始化数组： constexpr auto A = make_2d_array<int, 2, 3, 1>(); // Y=2, X=3, init value 1 std:：fill_n（&A[0][0]，sizeof（A）/sizeof（**A），1）查看有关填充的更多信息希望它能解决您的问题。您可以使用fil

假设我声明一个矩阵，如下-->long long int a[100][100]。在声明矩阵时，有没有办法将值1分配给它的所有元素？

您可以使用fill\n方法并像这样初始化数组：

constexpr auto A = make_2d_array<int, 2, 3, 1>(); // Y=2, X=3, init value 1

std:：fill_n（&A[0][0]，sizeof（A）/sizeof（**A），1）
查看有关填充的更多信息
希望它能解决您的问题。
您可以使用fill\n方法初始化数组，如下所示：
constexpr auto A = make_2d_array<int, 2, 3, 1>(); // Y=2, X=3, init value 1

std:：fill_n（&A[0][0]，sizeof（A）/sizeof（**A），1）
查看有关填充的更多信息
希望它能解决你的问题
在声明矩阵时，是否有任何方法将值1分配给其所有元素
我将其解释为您需要某种constexpr
，我会使用std:：array
而不是普通数组，因为std:：array
更容易使用
我已经为创建一维数组的make_array
制作了模板，并使用第一组模板为创建二维数组的make_2d_array
制作了模板
模板的目标是，例如，如果我们想要一个包含2行3列int
的2d数组，其中所有int
都用1
初始化，则应创建该数组：
std::array<std::array<int, 3>, 2> A{{
    {1, 1, 1},
    {1, 1, 1}
}};

std:：数组A{{
{1, 1, 1},
{1, 1, 1}
}};

在下面的代码中，make_array（）
将创建内部数组，std:：array{1,1,1}
和make_2d_array（）
将等效于：
std::array<std::array<int, 3>, 2> A{
    make_array<int, 3, 1>(),         // std::array<int, 3>{1, 1, 1}
    make_array<int, 3, 1>()          // std::array<int, 3>{1, 1, 1}
};

std:：数组A{
make_array（），//std:：array{1,1,1}
make_array（）//std:：array{1,1,1}
};

以下是一组模板，可实现以下功能：
#include <array>
#include <type_traits>
#include <utility>

//-------------------------------------------------------------
template <typename T, T init, std::size_t... X>
constexpr std::array<T, sizeof...(X)>
make_array(std::index_sequence<X...>) {
    //
    //        used for folding only then discarded below
    //                                          |
    return std::array<T, sizeof...(X)>{ ((void)(X), (init))... };
}

template <typename T, std::size_t X, T init = T{}>
constexpr std::array<T, X> make_array() {
    return make_array<T, init>(std::make_index_sequence<X>{});
}
//-------------------------------------------------------------
template <typename T, T init, std::size_t X, std::size_t... Y>
constexpr std::array< std::array<T, X>, sizeof...(Y)>
make_2d_array(std::index_sequence<Y...>) {
    return std::array< std::array<T, X>, sizeof...(Y)>{
        //
        //      Y used for folding only and discarded
        //      |
        ((void)(Y), make_array<T, X, init>())... 
    };
}

template <typename T, std::size_t Y, std::size_t X, T init = T{}>
constexpr std::array<std::array<T, X>, Y>
make_2d_array() {
    return make_2d_array<T, init, X>(std::make_index_sequence<Y>{});
}

#包括
（如果您想查看折叠如何展开，请单击演示中左上角的链接）
在声明矩阵时，是否有任何方法将值1分配给其所有元素
我将其解释为您需要某种constexpr
，我会使用std:：array
而不是普通数组，因为std:：array
更容易使用
我已经为创建一维数组的make_array
制作了模板，并使用第一组模板为创建二维数组的make_2d_array
制作了模板
模板的目标是，例如，如果我们想要一个包含2行3列int
的2d数组，其中所有int
都用1
初始化，则应创建该数组：
std::array<std::array<int, 3>, 2> A{{
    {1, 1, 1},
    {1, 1, 1}
}};

std:：数组A{{
{1, 1, 1},
{1, 1, 1}
}};

在下面的代码中，make_array（）
将创建内部数组，std:：array{1,1,1}
和make_2d_array（）
将等效于：
std::array<std::array<int, 3>, 2> A{
    make_array<int, 3, 1>(),         // std::array<int, 3>{1, 1, 1}
    make_array<int, 3, 1>()          // std::array<int, 3>{1, 1, 1}
};

std:：数组A{
make_array（），//std:：array{1,1,1}
make_array（）//std:：array{1,1,1}
};

以下是一组模板，可实现以下功能：
#include <array>
#include <type_traits>
#include <utility>

//-------------------------------------------------------------
template <typename T, T init, std::size_t... X>
constexpr std::array<T, sizeof...(X)>
make_array(std::index_sequence<X...>) {
    //
    //        used for folding only then discarded below
    //                                          |
    return std::array<T, sizeof...(X)>{ ((void)(X), (init))... };
}

template <typename T, std::size_t X, T init = T{}>
constexpr std::array<T, X> make_array() {
    return make_array<T, init>(std::make_index_sequence<X>{});
}
//-------------------------------------------------------------
template <typename T, T init, std::size_t X, std::size_t... Y>
constexpr std::array< std::array<T, X>, sizeof...(Y)>
make_2d_array(std::index_sequence<Y...>) {
    return std::array< std::array<T, X>, sizeof...(Y)>{
        //
        //      Y used for folding only and discarded
        //      |
        ((void)(Y), make_array<T, X, init>())... 
    };
}

template <typename T, std::size_t Y, std::size_t X, T init = T{}>
constexpr std::array<std::array<T, X>, Y>
make_2d_array() {
    return make_2d_array<T, init, X>(std::make_index_sequence<Y>{});
}

#包括
（如果您想查看折叠的展开情况，请单击演示中左上角的链接）
如Ted Lyngmo所示，我们可以使用constepr
函数声明和初始化std:：array
，而不是long long int a[100][100]

从C++20开始，就可以使用
指定函数是立即函数，即对该函数的每次调用都必须生成编译时常量
此外，还对算法进行了constexpr

因此，我们可以编写以下两个函数模板：
#include <algorithm>
#include <array>

template <class Type, std::size_t Size>
consteval auto make_1d_array(Type value)
{
    std::array<Type, Size> result;
    std::fill_n(result.begin(), Size, value);
    return result;
}

template <class Type, std::size_t Rows, std::size_t Cols>
consteval auto make_2d_array(Type value)
{
    std::array<std::array<Type, Cols>, Rows> result;
    std::fill_n( result.begin(), Rows
               , make_1d_array<Type, Cols>(value) );
    return result;
}

#include.
如Ted Lyngmo所示，我们可以使用constexpr
函数声明和初始化std:：array
，而不是long-long-int-a[100][100]

从C++20开始，就可以使用
指定函数是立即函数，即对该函数的每次调用都必须生成编译时常量
此外，还对算法进行了constexpr

因此，我们可以编写以下两个函数模板：
#include <algorithm>
#include <array>

template <class Type, std::size_t Size>
consteval auto make_1d_array(Type value)
{
    std::array<Type, Size> result;
    std::fill_n(result.begin(), Size, value);
    return result;
}

template <class Type, std::size_t Rows, std::size_t Cols>
consteval auto make_2d_array(Type value)
{
    std::array<std::array<Type, Cols>, Rows> result;
    std::fill_n( result.begin(), Rows
               , make_1d_array<Type, Cols>(value) );
    return result;
}

#include.
此矩阵的类型是什么？请提供完整的声明。long long int A[100][100]以前有这样的问题：这个矩阵是什么类型的？请提供完整的声明。long long int A[100][100]以前有这样的问题：这是不正确的。将2d数组视为连续的内存块是一种未定义的行为。那么您还有其他选择吗？这是不正确的。将2d数组视为连续的内存块是一种未定义的行为。那么您还有其他选择吗？自从C++20以来，我们可以利用consteval
和std:：fill\n
beingconstepr
：。你认为折叠表达式和索引序列在编译时间或生成的代码方面有一些优势吗？@Bob_uuu哦，这是一个很好的C++20添加！我希望折叠和index\u序列
s会使编译速度慢一些。如果在整个程序中使用相同的维度，我不认为这是显而易见的，但是如果使用大量不同的维度，这可能是显而易见的。它不是递归的，因此实例的数量仍然相当低（使用的每个唯一的Y，X组合4个）。我通常更关心运行时，尽量不重建不受最近更改影响的部件。我希望这个答案能吸引有类似想法的人，也能吸引那些要求它的人（据我所知），顺便说一句，我建议你添加你的代码作为答案。它比我的要简单得多，如果OP可以使用C++20，那将是一笔交易。好吧，这是一笔大买卖。@Bob_uuu_uu我将在我的MSVC安装上试用它，brb。。。。编辑：不，甚至没有：-（…不过，这将是一个很好的答案（我投赞成票），我