blocks|key|787274|text|可变长度数组不是在标准c%2B%2B中扩展的。而且你不想要全局定义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|787275|在这种情况下，您可以使用的是std::vector。|offset|length|style|CODE|787276|void+f(std::vector<std::vector<int>>&+mat)
{

}

int+main()
{
++++cin+>>+x;
++++std::vector<std::vector<int>>+m(x,std::vector<int>(x));
++++f(m);
}|code-block|syntax|javascript|787277|如果将该向量传递给函数或在函数中分配，大小信息将随时保留。|787278|我能做些什么来创建一个在主函数之外大小为x的矩阵？|blockquote|787279|就像这样：|787280|std::vector<std::vector<int>>+foo()+{
++++cin+>>+x;
++++std::vector<std::vector<int>>+m(x,std::vector<int>(x));
++++return+m;
}

int+main()
{
++++std::vector<std::vector<int>>+mat+=+foo();
}|787281|entityMap^0|0|E|B|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|11|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|12|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|13|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|14|8|@]|9|@]|A|$]]|$1|T|3|U|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|V|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|W|$]]

Variable length arrays aren't spported in standard c++. Besides you don't want the global definition.

What you can use portably in that case is <code>std::vector</code>:

<pre><code>void f(std::vector&lt;std::vector&lt;int&gt;&gt;&amp; mat)
{

}

int main()
{
 cin &gt;&gt; x;
 std::vector&lt;std::vector&lt;int&gt;&gt; m(x,std::vector&lt;int&gt;(x));
 f(m);
}
</code></pre>

If you pass that vector around to functions or being allocated within functions, the size information will be kept at any time.

<blockquote>
 What can I do to create a matrix with the size of x outside of the main function?
</blockquote>

Something like this:

<pre><code>std::vector&lt;std::vector&lt;int&gt;&gt; foo() {
 cin &gt;&gt; x;
 std::vector&lt;std::vector&lt;int&gt;&gt; m(x,std::vector&lt;int&gt;(x));
 return m;
}

int main()
{
 std::vector&lt;std::vector&lt;int&gt;&gt; mat = foo();
}
</code></pre>

blocks|key|787302|text|您可以使用动态分配内存，在c/c%2B%2B中，它不支持静态内存分配的动态大小，因此，您只需像这样修改代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|787303|int+x;
cin+>>x;
int**+mat+=+new+int[x][x];|code-block|syntax|javascript|787304|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can dynamic allocate memory to use, in the c/c++, it does not support dynamic size of static memory allocation, so, you just modify your code like this.

<pre><code>int x;
cin &gt;&gt;x;
int** mat = new int[x][x];
</code></pre>

blocks|key|335926|text|某些编译器支持可变长度数组作为扩展。编译器的手册提供了更多信息。Gnu+VLR。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|335927|变量长度数组的存储时间(如果支持的话)通常不能是静态的，这就是为什么您得到了错误消息(全局变量具有静态存储持续时间)。|335928|无关:不需要参数mat2的主要数组界，即void+f(int+mat2[x][x])等效于void+f(int+mat2[][x])。|style|CODE|335929|entityMap|0|LINK|mutability|MUTABLE|url|https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html^0|W|7|0|0|0|8|4|K|M|19|L|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|W|8|@$A|X|B|Y|H|I]|$A|Z|B|10|H|I]|$A|11|B|12|H|I]]|9|@]|C|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]]]

Variable-length array is supported by some compiler as an extension. The manual of the compiler provides more information.<a href="https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html" rel="nofollow noreferrer">Gnu VLR</a>

The storage duration of a variable-length array(if supported) generally can't be static, which is why you get the error message (global variables have static storage duration).

Unrelated: The major array bound of the parameter <code>mat2</code> isn't necessary, i.e. <code>void f(int mat2[x][x])</code> is equivalent to <code>void f(int mat2[][x])</code>.

blocks|key|2052763|text|在C%2B%2B中处理多维数组并不容易.最好的方法通常是用线性内存块映射多维索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2052764|例如，对于2×2矩阵，可以创建一个2*2=4元素数组，并以这样的方式映射它：|2052765|%2B-----------%2B-----------%2B-----------%2B-----------%2B
%7C+map[0][0]+%7C+map[0][1]+%7C+map[1][0]+%7C+map[1][1]+%7C
%2B-----------%2B-----------%2B-----------%2B-----------%2B|code-block|syntax|javascript|2052766|乍一看，这似乎过于复杂，但它大大简化了内存分配。|2052767|对于width任意大小的height矩阵，map[i][j]位于索引i*height+%2B+j。这可以在C%2B%2B中翻译，封装在模板类Matrix中。|offset|length|style|CODE|2052768|#include+<array>
template+<typename+T,+size_t+WIDTH,+size_t+HEIGHT>
class+Matrix+{
++++std::array<T,+WIDTH*HEIGHT>+data;

public:++++
++++T&+operator()(size_t+i,+size_t+j)+{
++++++++return+data[i*HEIGHT+%2B+j];
++++}
++++const+T&+operator()(size_t+i,+size_t+j)+const+{
++++++++return+data[i*HEIGHT+%2B+j];
++++}
};|2052769|这有一个缺点，即Matrix的维度必须在编译时就知道(并且可以减轻，请参阅答案末尾的注意(ii)+)。但它使它的使用变得如此容易：|2052770|void+fill(Matrix<int,+2,+2>&+m)+{
++++m(0,0)+=+0;
++++m(0,1)+=+1;
++++m(1,0)+=+2;
++++m(1,1)+=+3;
}

int+main()+{
++++Matrix<int,+2,+2>+m;
++++fill(m);
++++std::cout+<<+m(1,0)+<<+"\n";
}|2052771|注意(i)：元素是由(line,+column)而不是[line][column]索引的，因为我们不能创建接受多个值的operator[]。|2052772|住在coliru|2052773|注(ii)：这个基本思想是可以被丰富(演示)来处理可调整大小的矩阵，使用std::vector而不是std::array和std::vector::resize()的代理。|2052774|entityMap|0|LINK|mutability|MUTABLE|url|http://coliru.stacked-crooked.com/a/14216060b381a409|1|http://coliru.stacked-crooked.com/a/dc6278502bb9c11a^0|0|0|0|0|2|5|C|6|L|9|Y|C|1S|6|0|0|8|6|0|0|A|E|R|E|1N|A|0|0|8|0|0|10|B|1E|A|1P|L|D|9|1|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1G|8|@$M|1H|N|1I|O|P]|$M|1J|N|1K|O|P]|$M|1L|N|1M|O|P]|$M|1N|N|1O|O|P]|$M|1P|N|1Q|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1R|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1S|8|@$M|1T|N|1U|O|P]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1V|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1W|8|@$M|1X|N|1Y|O|P]|$M|1Z|N|20|O|P]|$M|21|N|22|O|P]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|23|8|@]|9|@$M|24|N|25|1|26]]|A|$]]|$1|10|3|11|5|6|7|27|8|@$M|28|N|29|O|P]|$M|2A|N|2B|O|P]|$M|2C|N|2D|O|P]]|9|@$M|2E|N|2F|1|2G]]|A|$]]|$1|12|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]]|13|$14|$5|15|16|17|A|$18|19]]|1A|$5|15|16|17|A|$18|1B]]]]

Handling of multi-dimension arrays in C++ is not easy. The best way to go is often to map a multi-dimensionnal indexing with a linear memory chunk.

For instance, for a 2 by 2 matrix, one can create an array of 2*2=4 elements and map it this way:

<pre><code>+-----------+-----------+-----------+-----------+
| map[0][0] | map[0][1] | map[1][0] | map[1][1] |
+-----------+-----------+-----------+-----------+
</code></pre>

This seems overly complicated at first glance, but it simplifies greatly the memory allocation.

For an arbitrary sized matrix of <code>width</code> by <code>height</code>, <code>map[i][j]</code> is at index <code>i*height + j</code>. This can be translated in C++, encapsulated in a template class <code>Matrix</code>:

<pre><code>#include &lt;array&gt;
template &lt;typename T, size_t WIDTH, size_t HEIGHT&gt;
class Matrix {
 std::array&lt;T, WIDTH*HEIGHT&gt; data;

public: 
 T&amp; operator()(size_t i, size_t j) {
 return data[i*HEIGHT + j];
 }
 const T&amp; operator()(size_t i, size_t j) const {
 return data[i*HEIGHT + j];
 }
};
</code></pre>

This has the disadvantage that the <code>Matrix</code>' dimensions must be known at compile time (and can be mitigated, see note (ii) at end of answer). But it makes its use so easy:

<pre><code>void fill(Matrix&lt;int, 2, 2&gt;&amp; m) {
 m(0,0) = 0;
 m(0,1) = 1;
 m(1,0) = 2;
 m(1,1) = 3;
}

int main() {
 Matrix&lt;int, 2, 2&gt; m;
 fill(m);
 std::cout &lt;&lt; m(1,0) &lt;&lt; "\n";
}
</code></pre>

Note (i): Elements are indexed by <code>(line, column)</code> rather than <code>[line][column]</code> because we can't create an <code>operator[]</code> accepting multiple values.

<a href="http://coliru.stacked-crooked.com/a/14216060b381a409" rel="nofollow noreferrer">Live on coliru</a>

Note (ii): This basic idea <a href="http://coliru.stacked-crooked.com/a/dc6278502bb9c11a" rel="nofollow noreferrer">can be enriched (demo)</a> to handle resizable matrixes, with use of a <code>std::vector</code> instead of <code>std::array</code> and a proxy to <code>std::vector::resize()</code>.

blocks|key|787385|text|C%2B%2B没有提供动态2D矩阵，但提供了创建复杂类所需的全部功能。(静态)+2D数组是由宽度元素的高度数组连续分配的数组。只是模仿一下，然后：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|787386|分配宽度*高度的线性数组|unordered-list-item|787387|提供一个返回指向ith行的第一个元素的指针的operator[](int)。|offset|length|style|CODE|787388|在析构函数和副本中执行必要的内部管理(如果C%2B%2B11或以上)，则移动构造函数。|787389|代码示例：|787390|template+<typename+T>
class+Matrix+{
++++T+*data;
++++int+width;
++++int+height;

public:
++++//+direct+ctor
++++Matrix(int+h,+int+w):+width(w),+height(h)+{
++++++++data+=+new+T[w+*+h];
++++}

++++//copy+ctor
++++Matrix(const+Matrix&+src):+width(src.width),+height(src.height)+{
++++++++data+=+new+T[width+*+height];+++//+allocate+and+copy+data+array
++++++++for+(int+i=0;+i<width+*+height;+i%2B%2B)+data[i]+=+src.data[i];
++++}

++++//+move+ctor
++++Matrix(Matrix&&+src):+width(src.width),+height(src.height)+{
++++++++data+=+src.data;++//+steal+original+array+in+a+move
++++++++src.data+=+NULL;++//+ensure+no+deletion+will+occur+at+src+destruction
++++}

++++~Matrix()+{
++++++++delete+data;
++++++++data+=+NULL;
++++}

++++//+explicitely+delete+assignement+operators
++++Matrix&+operator+=+(const+Matrix&)+=+delete;
++++Matrix&+operator+=+(Matrix&&)+=+delete;

++++T*+operator[](int+i)+{
++++++++//optionaly+test+0+<=+i+<+width
++++++++return+&data[i+*+width];
++++}
};

int+main()
{
++++int+w;
++++std::cin+>>+x;
++++Matrix<int>+m(x,+x);
++++//+you+can+then+use+m[i][j]+as+you+would+for+a+static+2D+array
++++...
}|code-block|syntax|javascript|787391|此类不支持按设计调整大小。如果您需要这样做，您确实应该使用vector<vector<T>+>。缺点是它也没有默认的ctor，因为维度必须在定义时给出(即使我们可以很容易地想象2阶段初始化.)。|787392|entityMap^0|0|0|M|F|0|0|0|0|T|I|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|Z|8|@$G|10|H|11|I|J]]|9|@]|A|$]]|$1|K|3|L|5|D|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|Q|7|14|8|@]|9|@]|A|$R|S]]|$1|T|3|U|5|6|7|15|8|@$G|16|H|17|I|J]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|W|$]]

C++ has no provision for dynamic 2D matrix but provides all you need to create complex classes. A (static) 2D array is a contiguously allocated array of height arrays of width elements. Just mimic that and:

<ul>
<li>allocate a linear array of width * height</li>
<li>provide an <code>operator[](int)</code> that returns a pointer to the first element of ith row</li>
<li>do necessary housekeeping in destructor and in a copy (and move if C++11 or above) constructor.</li>
</ul>

Example of code:

<pre><code>template &lt;typename T&gt;
class Matrix {
 T *data;
 int width;
 int height;

public:
 // direct ctor
 Matrix(int h, int w): width(w), height(h) {
 data = new T[w * h];
 }

 //copy ctor
 Matrix(const Matrix&amp; src): width(src.width), height(src.height) {
 data = new T[width * height]; // allocate and copy data array
 for (int i=0; i&lt;width * height; i++) data[i] = src.data[i];
 }

 // move ctor
 Matrix(Matrix&amp;&amp; src): width(src.width), height(src.height) {
 data = src.data; // steal original array in a move
 src.data = NULL; // ensure no deletion will occur at src destruction
 }

 ~Matrix() {
 delete data;
 data = NULL;
 }

 // explicitely delete assignement operators
 Matrix&amp; operator = (const Matrix&amp;) = delete;
 Matrix&amp; operator = (Matrix&amp;&amp;) = delete;

 T* operator[](int i) {
 //optionaly test 0 &lt;= i &lt; width
 return &amp;data[i * width];
 }
};

int main()
{
 int w;
 std::cin &gt;&gt; x;
 Matrix&lt;int&gt; m(x, x);
 // you can then use m[i][j] as you would for a static 2D array
 ...
}
</code></pre>

This class does not support any resizing by design. If you need that, you really should use a <code>vector&lt;vector&lt;T&gt; &gt;</code>. The downside is that it has no default ctor either, because the dimension must be given at definition time (even if we could easily imagine a 2 phases initialization...).

I'm a high school student learning programming and I have a problem that I can't figure out how to solve.

I have an integer "x", and I want a matrix "mat" to have the size of "x":

<pre><code>int mat[x][x];
</code></pre>

But that works only in <code>main()</code> where I've read <code>x</code>;

For example if <code>x == 5</code>, the equivalent would be

<code>int mat[5][5];</code>

<pre><code>#include &lt;iostream&gt;
using namespace std;

int x;

int mat[x][x];

void f(int mat2[x][x])
{

}

int main()
{
 cin &gt;&gt; x;
 int m[x][x];
 f(m);
}
</code></pre>

I've wrote this short program to show where it works and it doesn't work.

<blockquote>
 error: array bound is not an integer constant before <code>']'</code> token
</blockquote>

I've the error at the global declaration, at the declaration in function <code>void f</code>. It only compiles without errors in <code>main()</code>;

What can I do to create a matrix with the size of <code>x</code> outside of the main function?

Array of a specific size used out of the function it was initialized in

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我是一个高中生，学习编程，我有一个问题，我不知道如何解决。我有一个整数"x"，我想要一个矩阵"mat“的大小为"x"：int mat[x][x];但这只适用于我读过x的x；例如，如果是x == 5，则等效为int mat[5][5];#include <iostream>using namespace std;int ...

问中初始化的函数之外的特定大小的数组。
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问中初始化的函数之外的特定大小的数组。EN