blocks|key|937982|text|使用return？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937983|Criteria+*
newCriteria()+{
+++Criteria+*criteria+=+malloc(..);
+++...
+++return+criteria;
}

/*+the+caller+*/
Criteria+*c1+=+newCriteria();
Criteria+*c2+=+newCriteria();|code-block|syntax|javascript|937984|编辑|offset|length|style|BOLD|937985|调用者负责调用free()|937986|entityMap^0|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

using return? 

<pre><code>Criteria *
newCriteria() {
 Criteria *criteria = malloc(..);
 ...
 return criteria;
}

/* the caller */
Criteria *c1 = newCriteria();
Criteria *c2 = newCriteria();
</code></pre>

EDIT

the caller is responsible for calling free()

blocks|key|938004|text|您可以“返回”指向已分配内存的指针。如果返回NULL，则表示分配不成功。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938005|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You can "return" the pointer to the allocated memory. If NULL is returned, that means the allocation was unsuccessful.

blocks|key|938030|text|您有两种可能的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|938031|+int+*CallIntAllocation(int+nCount)
+{

+++++int+*nCheck+=+(int*)malloc(nCount*+sizeof(int));
+++++for+(int+j+=+0;+j+<+nCount;+j%2B%2B)
+++++++++nCheck[j]+=+0;

+++++return+nCheck;
+}

+int*+nCheck+=+NULL;
+int+nCount+=+4;

+nCheck+=+CallIntAllocation(nCount);|code-block|syntax|javascript|938032|或者，如果你想分配数组，你应该向int*传递一个指针：|938033|+void+CallIntAllocation(int+**nCheck,+int+nCount)
+{

+++++*nCheck+=+(int*)malloc(nCount*+sizeof(int));
+++++for+(int+j+=+0;+j+<+nCount;+j%2B%2B)
+++++++++*nCheck[j]+=+0;
+}

+int*+nCheck+=+NULL;
+int+nCount+=+4;

+CallIntAllocation(&nCheck,+nCount);+|938034|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|$]]

You have 2 possible solutions:

<pre><code> int *CallIntAllocation(int nCount)
 {

 int *nCheck = (int*)malloc(nCount* sizeof(int));
 for (int j = 0; j &lt; nCount; j++)
 nCheck[j] = 0;

 return nCheck;
 }

 int* nCheck = NULL;
 int nCount = 4;

 nCheck = CallIntAllocation(nCount);
</code></pre>

or you should pass a pointer to int* if you want to alloc array:

<pre><code> void CallIntAllocation(int **nCheck, int nCount)
 {

 *nCheck = (int*)malloc(nCount* sizeof(int));
 for (int j = 0; j &lt; nCount; j++)
 *nCheck[j] = 0;
 }

 int* nCheck = NULL;
 int nCount = 4;

 CallIntAllocation(&amp;nCheck, nCount); 
</code></pre>

blocks|key|1334351|text|要直接回答您的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1334352|int*+nCheck+=+NULL;
int+nCount+=+4;

CallIntAllocation(&nCheck,+nCount);

nCheck[1]+=+3;+//+allocated!
...

void+CallIntAllocation(int**+pnCheck,+int+nCount)
{
++++int*+nCheck+=+NULL;
++++nCheck+=+(int*)+malloc(nCount+*+sizeof(*nCheck));
++++for+(int+j+=+0;+j+<+nCount;+j%2B%2B)
++++++++nCheck[j]+=+0;
++++*pnCheck+=+nCheck;
}|code-block|syntax|javascript|1334353|但我建议这样做：|1334354|nCheck+=+CallIntAllocation(nCount);

nCheck[1]+=+3;+//+allocated!
...
int+*CallIntAllocation(int+nCount)
{
++++int+*+nCheck
++++nCheck+=+(int*)+malloc(nCount+*+sizeof(*nCheck));
++++for+(int+j+=+0;+j+<+nCount;+j%2B%2B)
++++++++nCheck[j]+=+0;
++++return+nCheck;
}|1334355|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|$]]

To answer your question directly:

<pre><code>int* nCheck = NULL;
int nCount = 4;

CallIntAllocation(&amp;nCheck, nCount);

nCheck[1] = 3; // allocated!
...

void CallIntAllocation(int** pnCheck, int nCount)
{
 int* nCheck = NULL;
 nCheck = (int*) malloc(nCount * sizeof(*nCheck));
 for (int j = 0; j &lt; nCount; j++)
 nCheck[j] = 0;
 *pnCheck = nCheck;
}
</code></pre>

but I would suggest this in stead:

<pre><code>nCheck = CallIntAllocation(nCount);

nCheck[1] = 3; // allocated!
...
int *CallIntAllocation(int nCount)
{
 int * nCheck
 nCheck = (int*) malloc(nCount * sizeof(*nCheck));
 for (int j = 0; j &lt; nCount; j++)
 nCheck[j] = 0;
 return nCheck;
}
</code></pre>

blocks|key|31540|text|它不工作的原因是C中的函数参数被复制了。因此，在外部上下文中，nCheck+=+NULL，您将其传递给CallIntAllocation函数并创建一个副本。CallIntAllocation将其nCheck的本地副本定义为malloc调用的返回值。但是外部副本不会更新--它仍然指向NULL。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|31541|最简单的解决方案是返回新的指针值，并按照几个人的建议进行赋值。|31542|当您有需要修改数据结构的函数时，您需要传递一个指向它们的指针，而不是它们的副本，以便函数可以修改指针所指向的内容。同样的原理也适用于这里，尽管您想要修改的数据结构本身就是一个指针。|31543|因此，另一种解决方案是CallIntAllocation将指针指向指针，这将允许您修改指针指向的位置，并取消对其的引用：|31544|CallIntAllocation(int**+nCheck,+int+nCount)
{

++++*nCheck+=+(int*)malloc(nCount*+sizeof(int));
++++for+(int+j+=+0;+j+<+nCount;+j%2B%2B)
++++++++(*nCheck)[j]+=+0;
}|code-block|syntax|javascript|31545|和调用|31546|CallIntAllocation(&nCheck,+nCount);|31547|显然，在这种情况下，返回一个新的指针值是明智的方法。|31548|最后一点:如果您有可用的"memset“(C90，但不是C89+afaik，它是单个unix规范的一部分)，则可以使用它来代替"for”循环。|31549|memset(ncheck,+0,+nCount);|31550|(这是针对您的函数版本，而不是接受int+**参数的版本)|31551|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|J|7|19|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

The reason it is not working is that function arguments in C are copied. So, nCheck = NULL in the outside context, you pass it into the CallIntAllocation function and a copy is made. The CallIntAllocation defines it's local copy of nCheck to be the return of the malloc call. But the outer copy is not updated -- it still points at NULL.

The simplest solution is to return the new pointer value and assign it as already suggested by several people.

When you have functions that need to modify data structures, you need to pass around a pointer to them, rather than copies of them, so that the function can modify what the pointer points at. The same principle applies here, although the data structure you want to modify is itself a pointer.

So another solution would be for CallIntAllocation to take a pointer-to-a-pointer which would let you modify where the pointer points, and also dereference it:

<pre><code>CallIntAllocation(int** nCheck, int nCount)
{

 *nCheck = (int*)malloc(nCount* sizeof(int));
 for (int j = 0; j &lt; nCount; j++)
 (*nCheck)[j] = 0;
}
</code></pre>

and invocation

<pre><code>CallIntAllocation(&amp;nCheck, nCount);
</code></pre>

Clearly in this situation returning a new pointer value is the sensible approach.

Final point: if you have it available, "memset" (C90 but not C89 afaik, part of the single unix specification however) can be used in place of your "for" loop

<pre><code>memset(ncheck, 0, nCount);
</code></pre>

(that's for your version of the function, not the one that takes an int ** argument)

I d love to know how I can allocate data through a function, and after the function is returned the data is still allocated. This is both for basic types (int, char**) and user defined types. Below are two snipsets of code. Both have the allocation within the function though after the return the allocation goes.

<pre><code>int* nCheck = NULL;
int nCount = 4;

CallIntAllocation(nCheck, nCount);

nCheck[1] = 3; // Not allocated!
...

CallIntAllocation(int* nCheck, int nCount)
{

 nCheck = (int*)malloc(nCount* sizeof(int));
 for (int j = 0; j &lt; nCount; j++)
 nCheck[j] = 0;
}
</code></pre>

The same behaviour for as before though for user defined type:

<pre><code>typedef struct criteriatype
{
 char szCriterio[256];
 char szCriterioSpecific[256];
} _CriteriaType;

typedef struct criteria
{
 int nCount;
 char szType[128];
 _CriteriaType* CriteriaType;
} _Criteria;

...
_Criteria* Criteria;
AllocateCriteria(nTypes, nCriteria, Criteria);
...

void AllocateCriteria(int nTypes, int nCriteria[], _Criteria* Criteria)
{
 int i = 0;
 int j = 0;

 Criteria = (_Criteria*)malloc(nTypes * sizeof(_Criteria));

 for (i = 0; i &lt; nTypes; i ++)
 {
 // initalise FIRST the whole structure
 // OTHERWISE the allocation is gone
 memset(&amp;Criteria[i],'\0',sizeof(_Criteria));

 // allocate CriteriaType
 Criteria[i].CriteriaType = (_CriteriaType*)malloc(nCriteria[i] * sizeof(_CriteriaType));

 // initalise them
 for (j = 0; j &lt; nCriteria[i]; j ++)
 memset(&amp;Criteria[i].CriteriaType[j],'\0',sizeof(_CriteriaType));


 }

}
</code></pre>

Any ideas? I think I need to pass the pointers as a reference, though how can i do so?

Thanks in advance,
Sunscreen

Allocate data through a function (ANSI C)

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想知道如何通过函数分配数据，并且在函数返回后，数据仍然是分配的。这既适用于基本类型(int、char**)，也适用于用户定义类型。下面是两个代码片段集。两者在函数中都有分配，但在返回之后分配就会发生。int* nCheck = NULL;int nCount = 4;CallIntAllocation(nCheck,...

问通过函数分配数据(ANSI C)
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过函数分配数据(ANSI C)EN