blocks|key|3786062|text|感谢所有参与这项活动的人！sskuce提供了一个非常好的解决方案，利用了“容器”。我曾考虑过这一点，但并不是真的喜欢额外的东西。我意识到在有点混乱之后，James+McNellis一直都给出了答案。所以..。下面是我更喜欢的没有容器和索引算法的解决方案(注意括号)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3786063|void+Scope1()+
{
++++int+array[2][3][4];
++++Scope2(&array);
}

int+(*pArray)[2][3][4];

void+Scope2(int+(*tpArray)[2][3][4]))+
{
++++pArray+=+tpArray;
++++(*pArray)[0][0][0]+=+3;
}|code-block|syntax|javascript|3786064|再次感谢大家。|3786065|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Thanks to everyone who participated in this! sskuce provided a very good solution, taking advantage of a "container". I had thought about this but didn't really like the extra stuff.
I realized after a little jumbling that James McNellis had given the answer all along. So... here's the solution I prefer with no containers and no indexes arithmetic (mind the parenthesis):

<pre><code>void Scope1() 
{
 int array[2][3][4];
 Scope2(&amp;array);
}

int (*pArray)[2][3][4];

void Scope2(int (*tpArray)[2][3][4])) 
{
 pArray = tpArray;
 (*pArray)[0][0][0] = 3;
}
</code></pre>

Thanks again to everyone.

blocks|key|2189105|text|如果你真的想通过引用传递数组，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2189106|void+f(int+(&a)[2][3][4])+{+}|code-block|syntax|javascript|2189107|在没有引用的C中，你可以通过指针传递数组(当然，这在C%2B%2B中也是有效的)：|2189108|void+f(int+(*a)[2][3][4])+{+}|2189109|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you really want to pass the array by reference, you can do so:

<pre><code>void f(int (&amp;a)[2][3][4]) { }
</code></pre>

In C, which doesn't have references, you can pass the array by pointer (this works in C++ too, of course):

<pre><code>void f(int (*a)[2][3][4]) { }
</code></pre>

blocks|key|1410079|text|C%2B%2B：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1410080|void+f(int+(&array)[2][3][4])
{
}|code-block|syntax|javascript|1410081|C:+C中没有引用|1410082|请注意，无论您如何传递数组，通过引用或不通过引用，数组都不会被复制，因此您将获得原始指针。你也可以像这样传递这个数组：|1410083|void+f(int+array[][3][4])
{
}|1410084|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

C++:

<pre><code>void f(int (&amp;array)[2][3][4])
{
}
</code></pre>

C: There are no references in C

Note that no matter how you pass the array, via reference or not, the array is not going to be copied, so you'll get the original pointer. You can pass this array also like this:

<pre><code>void f(int array[][3][4])
{
}
</code></pre>

blocks|key|3785913|text|编辑:我将我的原始答案保留在下面，因为我相信人们有必要了解数组是如何传递给函数的，以及它们是如何在内存中布局的，但经过进一步思考，我认为有一种简单而正确的方法可以完成您想要的工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3785914|将数组封装在结构中，例如|3785915|typedef+struct+ArrayHolderStruct{
++++int+array[2][3][4];
}+ArrayHolder

//...
//scope+1
ArrayHolder+thingy;
thingy.array[0]+=+something;
//other+initialization.
F(+&thingy+);
//...

//scope+2
ArrayHolder+*pa;
void+F+(+ArrayHolder+*p+){
++++pa+=+p;
++++p->array[0][1][2]+=+42;
}

//Call+F+first+to+set+pa.
void+G(){
++++pa->array[0][1][2]+=+6+*+9;+//+if+pa+=+&thingy,+thingy+will+be+modified.
}|code-block|syntax|javascript|3785916|该结构将允许您维护有关封装数组的布局信息，并且您不必担心繁琐的索引算法。|3785917|-旧答案-传递对数组的引用是没有用的，除非你想改变数组的大小或布局(你无论如何都不能用静态大小的数组做这件事)。即使通过"value“传递数组，您也会得到数组元素的引用(或指针)。也就是说，如果你声明了你的函数：|3785918|void+f+(+int+a[2][3][4]+){
++++a[0][1][2]+=+42;
}|3785919|并像调用f(+array+)一样调用它。当f退出时，array[0][2][2]将被设置为42，即使您没有向函数传递对array的“引用”。|offset|length|style|CODE|3785920|如果你想保存一个指向数组的指针，以便以后在库函数中使用，你可以这样做：|3785921|//scope+2
int+*+pa;
void+f+(+int+a[2][3][4]+){
++++pa+=+&a[0][0][0];
}|3785922|在这一点上它变得很棘手-你必须知道pa是如何布局的(布局？)在内存中。我认为C已经标准化了“行主顺序”，所以数组应该在内存中布局，如下所示：|3785923|a[0][0][0]+a[0][0][1]+a[0][0][2]+a[0][0][3]+a[0][1][0]+...+a[0][2][3]+a[1][0][0]+a[1][0][1]...+a[1][2][3]|3785924|因此，要获取索引[n][j][k]处的元素，您必须执行以下操作：|3785925|pa[n+*+12+%2B+j+*+4+%2B+k]+=+something;|3785926|基本上，将每个索引乘以可由该顺序的索引引用的元素的数量，例如，给定固定的j和n索引，每个k索引仅指向一个元素，给定固定的n索引，每个j索引可以指向4个元素，并且每个n索引可以指向12个元素中的一个(因为12+=3*+4)。|3785927|就像我说的，这很棘手。请参阅Array+Data+Structures和Row-major+order上的维基百科文章，以更好地了解这些内容是如何布局的。|3785928|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Array_data_structure#Compact_layouts|1|http://en.wikipedia.org/wiki/Row-major_order^0|0|0|0|0|0|0|4|A|L|1|Q|E|1N|5|0|0|0|0|0|8|9|0|0|10|1|12|1|18|1|1O|1|1U|1|2A|1|0|E|L|0|10|F|1|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1M|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1N|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1O|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|1P|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|1Q|8|@$Q|1R|R|1S|S|T]|$Q|1T|R|1U|S|T]|$Q|1V|R|1W|S|T]|$Q|1X|R|1Y|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|20|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|21|8|@]|9|@]|A|$]]|$1|10|3|11|5|F|7|22|8|@]|9|@]|A|$G|H]]|$1|12|3|13|5|6|7|23|8|@$Q|24|R|25|S|T]]|9|@]|A|$]]|$1|14|3|15|5|F|7|26|8|@]|9|@]|A|$G|H]]|$1|16|3|17|5|6|7|27|8|@$Q|28|R|29|S|T]|$Q|2A|R|2B|S|T]|$Q|2C|R|2D|S|T]|$Q|2E|R|2F|S|T]|$Q|2G|R|2H|S|T]|$Q|2I|R|2J|S|T]]|9|@]|A|$]]|$1|18|3|19|5|6|7|2K|8|@]|9|@$Q|2L|R|2M|1|2N]|$Q|2O|R|2P|1|2Q]]|A|$]]|$1|1A|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H]]|1I|$5|1D|1E|1F|A|$1G|1J]]]]

Edit: I'm keeping my original answer below, as I believe it's necessary for folks to understand how arrays are actually passed to functions and how they're layed out in memory, but on further reflection I think there is a simple and correct way to get what you want done.

Encapsulate the array within a struct, e.g.

<pre><code>typedef struct ArrayHolderStruct{
 int array[2][3][4];
} ArrayHolder

//...
//scope 1
ArrayHolder thingy;
thingy.array[0] = something;
//other initialization.
F( &amp;thingy );
//...

//scope 2
ArrayHolder *pa;
void F ( ArrayHolder *p ){
 pa = p;
 p-&gt;array[0][1][2] = 42;
}

//Call F first to set pa.
void G(){
 pa-&gt;array[0][1][2] = 6 * 9; // if pa = &amp;thingy, thingy will be modified.
}
</code></pre>

The struct will allow you to maintain layout information about the encapsulated array, and you don't have to worry about nasty index arithmetic.

-----OLD ANSWER-----
Passing a reference to an array is not useful, unless you want to change the size or layout of the array (which you can't do with statically sized arrays anyway). You'll get a reference (or pointer) to the elements of the array even if you pass the array by "value". That is to say, if you declare your function:

<pre><code>void f ( int a[2][3][4] ){
 a[0][1][2] = 42;
}
</code></pre>

and call it like <code>f( array )</code> when <code>f</code> exits, <code>array[0][2][2]</code> will have been set to 42, even though you didn't pass a "reference" to <code>array</code> into the function.

If you want to save a pointer to the array for later use in a library function, etc, you could do something like:

<pre><code>//scope 2
int * pa;
void f ( int a[2][3][4] ){
 pa = &amp;a[0][0][0];
}
</code></pre>

It gets tricky at this point - you have to know how pa is layed (laid?) out in memory. I think C has standardized on 'row major order', so the array should be layed out in memory like:

<pre><code>a[0][0][0] a[0][0][1] a[0][0][2] a[0][0][3] a[0][1][0] ... a[0][2][3] a[1][0][0] a[1][0][1]... a[1][2][3]
</code></pre>

So, to get at an element at index <code>[n][j][k]</code>, you have to do something like:

<pre><code>pa[n * 12 + j * 4 + k] = something;
</code></pre>

Basically, multiply each index by the number of elements that can be referenced by an index of that order, e.g. each <code>k</code> index points to exactly one element given a fixed <code>j</code> and <code>n</code> index, each <code>j</code> index can point to 4 elements given a fixed <code>n</code> index, and each <code>n</code> index can point to one of 12 (because 12 = 3 * 4) elements.

Like I said, it's tricky. See the wikipedia articles on <a href="http://en.wikipedia.org/wiki/Array_data_structure#Compact_layouts" rel="nofollow">Array Data Structures</a> and <a href="http://en.wikipedia.org/wiki/Row-major_order" rel="nofollow">Row-major order</a> to get a better understanding of how these things are layed out.

Can anyone hint on how to pass by reference an array of the kind 

<pre><code>int array[2][3][4];
</code></pre>

so that I may save his pointer in order to use and modify the array? 
Like, if I were speaking about a single integer:

<pre><code>// Scope 1
int a = 3;
increment(&amp;a);
// End Scope 1

// Scope 2
int *pa;
void increment(int *tpa) { 
 pa = tpa; *pa++; 
}
// End Scope 2
</code></pre>

Thanks a lot and best regards.

Passing by reference 3-Dim Fixed length array

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

有人能提示一下如何通过引用传递这种类型的数组吗？int array[2][3][4];这样我就可以保存他的指针，以便使用和修改数组？比如，如果我说的是一个整数：// Scope 1int a = 3;increment(&a);// End Scope 1// Scope 2int *pa;void increment(int *tpa) {   pa = tpa; *pa++; }// End 

问通过引用传递3维定长数组
EN

回答 4

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过引用传递3维定长数组EN

回答 4

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过引用传递3维定长数组
EN