blocks|key|3519401|text|因为您是通过值传递两个指针(因此实际上是传递指针的副本)，所以将初始化函数更改为int+initilize(stack+**s)，将s+=+newStack;更改为*s+=+newStack;，然后像下面的initialize(&sA);+initialize(&sB);那样调用initialize(&sA);+initialize(&sB);|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3519402|您真的不应该动态地分配对象，除非您必须这样做，而且您也不应该对所分配的内存进行free()，这是内存泄漏。|3519403|entityMap^0|14|O|1U|D|2A|E|2V|X|3W|X|0|13|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

Because you're passing both pointers by value(so you're actually passing a copy of the pointer), change the initialize function to <code>int initilize(stack **s)</code> and <code>s = newStack;</code> to <code>*s = newStack;</code> then call initialize like this <code>initialize(&amp;sA); initialize(&amp;sB);</code>

You really shouldn't dynamically allocate objects unless you have to, also you're not <code>free()</code>ing the memory you allocated, that's a memory leak.

blocks|key|3519434|text|将指针传递给函数时，该函数将接收指针的副本。这通常是很好的，除非您正在更改/创建指针的开始地址。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3519435|在您的示例中，sA和sB不包含任何地址(当您将它们传递给initialize时，它们是指向任何内容的指针)。因此，您的initialize函数必须使用指针的地址，而不是指针本身的，才能为将在main中可见的指针分配一个地址。例如：|CODE|3519436|void+initialize(stack+**s)
{
++++stack+*newStack;
++++newStack+=+malloc(sizeof(*newStack));
++++newStack->count+=+0;

++++*s+=+newStack;
}

...

initialize+(&sA);|code-block|syntax|javascript|3519437|删除上面的双指针**s+(例如*s+=+newStack;)，将newStack的地址指定为指针s的值。|3519438|我还建议在将newStack的位置分配给*s之前检查分配是否成功。|3519439|void+initialize(stack+**s)
{
++++stack+*newStack;
++++if+(!(newStack+=+malloc(sizeof(*newStack))))+{
++++++++fprintf+(stderr,+"%25s()+error:+memory+allocation+failed.\n",+__func__);
++++++++exit+(EXIT_FAILURE);
++++}
++++newStack->count+=+0;

++++*s+=+newStack;
}|3519440|entityMap^0|Z|C|0|7|2|A|2|S|A|1N|A|2N|4|26|11|0|0|0|1G|8|3|F|E|W|8|1C|1|0|0|X|6|8|K|2|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|H]|$9|11|A|12|B|H]|$9|13|A|14|B|H]|$9|15|A|16|B|H]|$9|17|A|18|B|H]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|I|3|J|5|K|7|1B|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|H]|$9|1H|A|1I|B|H]|$9|1J|A|1K|B|H]|$9|1L|A|1M|B|H]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|H]|$9|1S|A|1T|B|H]]|D|@]|E|$]]|$1|R|3|S|5|K|7|1U|8|@]|D|@]|E|$L|M]]|$1|T|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|U|$]]

When you pass a pointer to a function, the function receives a copy of the pointer. This is generally fine, unless you are changing/creating the START address for the pointer.

In your case, <code>sA</code> and <code>sB</code> contain no address (they are pointers to nothing when you pass them to <code>initialize</code>). So your <code>initialize</code> function must take the address of the pointer rather than the pointer itself to assign an address to the pointer that will be visible in <code>main</code>. For example:

<pre><code>void initialize(stack **s)
{
 stack *newStack;
 newStack = malloc(sizeof(*newStack));
 newStack-&gt;count = 0;

 *s = newStack;
}

...

initialize (&amp;sA);
</code></pre>

Dereferencing the double pointer <code>**s</code> above, (e.g. <code>*s = newStack;</code>), assigns the address of <code>newStack</code> as the value for pointer <code>s</code>.

I would also suggesting checking that the allocation succeeded before assigning the location of <code>newStack</code> to <code>*s</code>:

<pre><code>void initialize(stack **s)
{
 stack *newStack;
 if (!(newStack = malloc(sizeof(*newStack)))) {
 fprintf (stderr, "%s() error: memory allocation failed.\n", __func__);
 exit (EXIT_FAILURE);
 }
 newStack-&gt;count = 0;

 *s = newStack;
}
</code></pre>

blocks|key|222587|text|我认为你需要以下几点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|222588|#include+<stdio.h>

#define+STACK_SIZE++5

typedef+struct+stackADT+
{
++++int+elements[STACK_SIZE];
++++int+count;
}+stack;

void+initialize(+stack+*s+)
{
++++s->count+=+0;
}

int+push(+stack+*s,+int+value+)
{
++++return+s->count+==+STACK_SIZE+?+-1+:+(+s->elements[s->count%2B%2B]+=+value+);
}

int+main(void)+
{
++++stack+sA;
++++stack+sB;

++++initialize(+&sA+);
++++initialize(+&sB+);

++++printf(+"%25d\n",+push(+&sA,+3+)+);

++++return+0;
}|code-block|syntax|javascript|222589|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|$]]

I think that you need something like the following

<pre><code>#include &lt;stdio.h&gt;

#define STACK_SIZE 5

typedef struct stackADT 
{
 int elements[STACK_SIZE];
 int count;
} stack;

void initialize( stack *s )
{
 s-&gt;count = 0;
}

int push( stack *s, int value )
{
 return s-&gt;count == STACK_SIZE ? -1 : ( s-&gt;elements[s-&gt;count++] = value );
}

int main(void) 
{
 stack sA;
 stack sB;

 initialize( &amp;sA );
 initialize( &amp;sB );

 printf( "%d\n", push( &amp;sA, 3 ) );

 return 0;
}
</code></pre>

blocks|key|3024657|text|您正在接收分段错误，因为您试图将push()中的值分配给未分配的内存区域。initialize()可以成功地分配内存并使用count+=+0初始化它，但是s+=+newStack的分配不起作用。正如David和Alejandro所指出的，您正在传递“指针的副本”。本质上，您传递的是未初始化的stack变量的地址，但不是传递函数--使用新地址更新该变量的方法。您需要将一个指针传递给堆栈指针。(也称为二级指针。)这意味着initialize()将接收保存堆栈结构内存地址的变量的内存地址。这样，函数就可以将二级指针的指针的地址分配给被调出的堆栈。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3024658|也许，只要简单地查看代码，就会更容易理解：|3024659|#define+STACK_SIZE+5

#include+<stdio.h>
#include+<stdlib.h>

typedef+struct+stackADT+{
++++int+elements[STACK_SIZE];
++++int+count;
}+stack;

void+initialize(stack+**s)
{
+++++stack+*newStack;
+++++newStack+=+malloc(sizeof(*newStack));

+++++if(NULL+==+newStack){
++++++++//+Malloc+could+not+allocate+memory
++++++++//+for+newStack.
++++++++//+Set+s+to+NULL+to+indicate+the+error
++++++++s+=+NULL;
++++++++//+Return+prematurely
++++++++return;
+++++}+//+else,+malloc+succeeded

+++++newStack->count+=+0;

+++++//+Assign+the+value+of+the+malloced+stack+pointer+to+the+pointee+of+stack+**s
+++++*s+=+newStack;
}

int+push(stack+*s,+int+value)
{
++++if(+s->count+==+STACK_SIZE+){
++++++++//+Stack+has+too+many+elements.
++++++++//+Return+with+error+value+(-1)
++++++++return+-1;
++++}+else+{
++++++++//+Assign+the+new+value+to+the+current+last+index
++++++++s->elements[s->count]+=+value;
++++++++//+Add+count+to+indicate+a+new+variable+has+been+added
++++++++s->count%2B%2B;
++++++++//+Use+the+array+to+return+the+value+just+added
++++++++return+s->elements[+(s->count+-+1)+];
++++}
}

int+main()
{
++++stack*+sA;
++++stack*+sB;

++++//+Send+the+function+a+pointer+to+the+stack+pointer
++++initialize(&sA);
++++initialize(&sB);

++++if(sA+==+NULL){
++++++++puts("Could+not+allocate+the+memory+for+stack+variable+sA.\n");
++++++++return+-1;
++++}

++++printf("%25d\n",+push(sA,+3)+);

++++//+Clean+up+the+memory
++++free(sA);
++++free(sB);

++++return+0;
}|code-block|syntax|javascript|3024660|我还稍微修改了代码，以便将value的赋值拆分到push()函数中，并添加了一个malloc()错误检查。|3024661|注意事项：如果您对此感到满意，我建议您使用Vlad的推送功能。它更短、更简洁；然而，它牺牲了可读性。因为你是个初学者，我决定把它传播出去可能更容易理解。|BOLD|3024662|entityMap^0|G|6|11|C|1P|9|25|C|42|5|5U|C|0|0|0|D|5|O|6|14|8|0|0|4|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|16|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1F|8|@$9|1G|A|1H|B|Q]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|S|$]]

you are receiving a segmentation fault because you are attempting to assign a value in <code>push()</code> to an unallocated area of memory. <code>initialize()</code> works to successfully allocate memory and initialize it with <code>count = 0</code>, but your assignment of <code>s = newStack</code> does not work. As David and Alejandro pointed out, you are passing "a copy of the pointer." In essence, you are passing the address of the uninitialized <code>stack</code> variable, but you are not passing the function a way to update that variable with the new address. You need to pass it a pointer to the stack pointer. (Also known as a level two pointer.) This means <code>initialize()</code> will receive the memory address of the variable that holds the memory address of the stack structure. As such, the function can then assign the level two pointer's pointee the address to the malloced stack.

Perhaps that would be easier to understand by simply looking at the code:

<pre><code>#define STACK_SIZE 5

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

typedef struct stackADT {
 int elements[STACK_SIZE];
 int count;
} stack;

void initialize(stack **s)
{
 stack *newStack;
 newStack = malloc(sizeof(*newStack));

 if(NULL == newStack){
 // Malloc could not allocate memory
 // for newStack.
 // Set s to NULL to indicate the error
 s = NULL;
 // Return prematurely
 return;
 } // else, malloc succeeded

 newStack-&gt;count = 0;

 // Assign the value of the malloced stack pointer to the pointee of stack **s
 *s = newStack;
}

int push(stack *s, int value)
{
 if( s-&gt;count == STACK_SIZE ){
 // Stack has too many elements.
 // Return with error value (-1)
 return -1;
 } else {
 // Assign the new value to the current last index
 s-&gt;elements[s-&gt;count] = value;
 // Add count to indicate a new variable has been added
 s-&gt;count++;
 // Use the array to return the value just added
 return s-&gt;elements[ (s-&gt;count - 1) ];
 }
}

int main()
{
 stack* sA;
 stack* sB;

 // Send the function a pointer to the stack pointer
 initialize(&amp;sA);
 initialize(&amp;sB);

 if(sA == NULL){
 puts("Could not allocate the memory for stack variable sA.\n");
 return -1;
 }

 printf("%d\n", push(sA, 3) );

 // Clean up the memory
 free(sA);
 free(sB);

 return 0;
}
</code></pre>

I have also modified the code slightly to split up the assignment of <code>value</code> in the <code>push()</code> function and I added a <code>malloc()</code> error check.

Note: If you are comfortable with it, I would recommend using Vlad's push function. It's shorter and more concise; however, it sacrifices readability. As you are a beginner, I decided spreading it out might be easier to understand.

I'm really sorry if this is an easy-fix-question, but I'm a beginner.
I have an assignment to write some functions to a stack-struct. The struct was given. I can't get rid of the segmentation fault in push() line "s->elements..."
I don't know what is wrong after hours googling and searching.

Here the code:
<pre><code>#define STACK_SIZE 5

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

typedef struct stackADT {
 int elements[STACK_SIZE];
 int count;
} stack;

void initialize(stack *s)
{
 stack *newStack;
 newStack = malloc(sizeof(*newStack));
 newStack-&gt;count = 0;

 s = newStack;
}

int push(stack *s, int value)
{
 if(s-&gt;count == 5) return -1;
 else {
 s-&gt;elements[s-&gt;count++] = value;
 return s-&gt;elements[s-&gt;count-1];
 }
}

int main()
{
 stack* sA;
 stack* sB;
 initialize(sA);
 initialize(sB);
 printf("%d\n",push(sA,3));
 return 0;
}
</code></pre>

C - Segmentation fault with struct

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

如果这是个很容易解决的问题，我真的很抱歉，但我是个初学者。我有个任务要写一些函数到堆栈结构。结构是给出的。我无法排除push()行“s->元素”中的分段错误.我不知道在搜索和搜索几个小时后有什么问题。在这里，代码：#define STACK_SIZE 5#include <stdio.h>#include <stdli...

问基于结构的C-分段故障
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问基于结构的C-分段故障EN