无法访问结构-C中字符数组的内存错误_C_Struct_Queue_Singly Linked List_Function Definition

无法访问结构-C中字符数组的内存错误

c struct

无法访问结构-C中字符数组的内存错误,c,struct,queue,singly-linked-list,function-definition,C,Struct,Queue,Singly Linked List,Function Definition,我试图使用C中的链表创建一个队列。我使用两个结构来表示队列和每个节点，如下所示 #define DATA_MAX 100 struct QueueNode_ch { struct QueueNode_ch* next; char data[(DATA_MAX + 1)]; }; typedef struct QueueNode_ch QueueNode_ch; struct Queue_ch { struct QueueNode_ch* front; str

我试图使用C中的链表创建一个队列。我使用两个结构来表示队列和每个节点，如下所示

#define DATA_MAX 100

struct QueueNode_ch 
{
    struct QueueNode_ch* next;
    char data[(DATA_MAX + 1)];
};
typedef struct QueueNode_ch QueueNode_ch;

struct Queue_ch
{
    struct QueueNode_ch* front;
    struct QueueNode_ch* rear;
    int count;
};
typedef struct Queue_ch Queue_ch;

然后，我使用以下函数初始化队列和节点

int initQueue_ch(Queue_ch* q)
{
    q = (Queue_ch*)malloc(sizeof(Queue_ch));
    q->count = 0;
    q->front = NULL;
    q->rear = NULL;
    return 0;
}

int initQueueNode_ch(QueueNode_ch* node)
{
    node = (QueueNode_ch*)malloc(sizeof(QueueNode_ch));
    node->next = NULL;
    node->data[0] = '\0';
    return 0;
}

在运行我的enqueue函数时，由于strcpy函数，我得到了一个seg错误，当调试gdb时，它说它无法访问我试图添加的节点的内存。排队代码如下：

int enqueue_ch(Queue_ch* q, char* data)
{
    if(strlen(data) > (DATA_MAX + 1))
        return 1;
    QueueNode_ch* tmp;
    initQueueNode_ch(tmp);
    strncpy(tmp->data, data, DATA_MAX);
    if(isEmpty_queue_ch(q))
        q->rear = q->front = tmp;
    else
    {
        q->rear->next = tmp;
        q->rear = tmp;
    }
    q->count++;
    return 0;
}

我还将包括我的主要职能作为附加信息

#include <stdio.h>
#include "Queue.h"

int main()
{
    Queue_ch* queue;
    initQueue_ch(queue);
    enqueue_ch(queue, "hello");
    return 0;
}

#包括
#包括“Queue.h”
int main（）
{
队列_ch*队列；
初始化队列（队列）；
排队（排队，“你好”）；
返回0；
}

据我所知，应该有足够的空间将给定字符串复制到节点。有人知道什么是失败的和可能的修复方法吗

int initQueue_ch(Queue_ch* q)
{
    q = (Queue_ch*)malloc(sizeof(Queue_ch));
    q->count = 0;
    q->front = NULL;
    q->rear = NULL;
    return 0;
}

此功能无法使用。它忽略传递给它的

的值，并且不返回指向它初始化的队列的指针。C是严格意义上的传递值

int main()
{
    Queue_ch* queue;
    initQueue_ch(queue);
    enqueue_ch(queue, "hello");
    return 0;
}

此代码从不给

queue

任何值，并将垃圾值传递给

initQueue\u ch

（忽略该值），然后将垃圾值传递给

enqueue\u ch

此功能无法使用。它忽略传递给它的

的值，并且不返回指向它初始化的队列的指针。C是严格意义上的传递值

int main()
{
    Queue_ch* queue;
    initQueue_ch(queue);
    enqueue_ch(queue, "hello");
    return 0;
}

这段代码从不给

队列

任何值，而是将垃圾值传递给

initQueue\u ch

（它忽略了该值），然后将垃圾值传递给

enqueue\u ch

，正如其他人提到的，您是按值传递结构。在C语言中，正确的方法是使用指向指针的指针。请注意，我还没有尝试编译这个，但希望想法是明确的

int initQueue_ch(Queue_ch** q)
{
    *q = (Queue_ch*)malloc(sizeof(Queue_ch));
    (*q)->count = 0;
    (*q)->front = NULL;
    (*q)->rear = NULL;
    return 0;
}

int initQueueNode_ch(QueueNode_ch** node)
{
    *node = (QueueNode_ch*)malloc(sizeof(QueueNode_ch));
    (*node)->next = NULL;
    (*node)->data[0] = '\0';
    return 0;
}

正如其他人提到的，您正在按值传递结构。在C语言中，正确的方法是使用指向指针的指针。请注意，我还没有尝试编译这个，但希望想法是明确的

int initQueue_ch(Queue_ch** q)
{
    *q = (Queue_ch*)malloc(sizeof(Queue_ch));
    (*q)->count = 0;
    (*q)->front = NULL;
    (*q)->rear = NULL;
    return 0;
}

int initQueueNode_ch(QueueNode_ch** node)
{
    *node = (QueueNode_ch*)malloc(sizeof(QueueNode_ch));
    (*node)->next = NULL;
    (*node)->data[0] = '\0';
    return 0;
}

函数

initQueue\u ch

没有意义

int initQueue_ch(Queue_ch* q)
{
    q = (Queue_ch*)malloc(sizeof(Queue_ch));
    q->count = 0;
    q->front = NULL;
    q->rear = NULL;
    return 0;
}

函数参数

是函数的局部变量。在函数中更改变量不会影响提供给函数的参数

此外，动态分配队列也没有意义。该函数可以按以下方式显示

void initQueue_ch( Queue_ch *q )
{
    q->count = 0;
    q->front = NULL;
    q->rear  = NULL;
}

QueueNode_ch * createQueueNode_ch( const char *data )
{
    QueueNode_ch *node = malloc( sizeof( QueueNode_ch ) );

    if ( node != NULL )
    {
        node->next = NULL;
        strcpy( node->data, data );
    }

    return node;
}

基本上你可以写作

Queue_ch queue;
initQueue_ch( &queue );

函数

initQueueNode\u ch

int initQueueNode_ch(QueueNode_ch* node)
{
    node = (QueueNode_ch*)malloc(sizeof(QueueNode_ch));
    node->next = NULL;
    node->data[0] = '\0';
    return 0;
}

同样，该函数处理传递参数值的副本。更改副本不会影响原始参数

该功能整体上没有意义。您需要的是一个分配新节点的函数

例如，它可以按以下方式查看

void initQueue_ch( Queue_ch *q )
{
    q->count = 0;
    q->front = NULL;
    q->rear  = NULL;
}

QueueNode_ch * createQueueNode_ch( const char *data )
{
    QueueNode_ch *node = malloc( sizeof( QueueNode_ch ) );

    if ( node != NULL )
    {
        node->next = NULL;
        strcpy( node->data, data );
    }

    return node;
}

函数

enqueue\u ch

具有按值传递队列指针的相同缺点

int enqueue_ch( Queue_ch *q, const char *data )
{
    int success = strlen( data ) < DATA_MAX + 1;

    if ( success )
    {
        QueueNode_ch *node = createQueueNode_ch( data );

        success = node != NULL;

        if ( success )
        {
            if ( q->rear == NULL )
            {
                q->front = q->rear = node;
            }
            else
            {
                q->rear = q->rear->next = node;
            }

            ++q->count;
        }
    }

    return success;
}

int排队（队列*q，常量字符*data）
{
int success=strlen（数据）rear==NULL）
{
q->front=q->rear=node；
}
其他的
{
q->rear=q->rear->next=节点；
}
++q->计数；
}
}
回归成功；
}

这是一个演示程序

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

#define DATA_MAX 100

struct QueueNode_ch 
{
    struct QueueNode_ch* next;
    char data[(DATA_MAX + 1)];
};
typedef struct QueueNode_ch QueueNode_ch;

struct Queue_ch
{
    struct QueueNode_ch* front;
    struct QueueNode_ch* rear;
    int count;
};
typedef struct Queue_ch Queue_ch;

void initQueue_ch( Queue_ch *q )
{
    q->count = 0;
    q->front = NULL;
    q->rear  = NULL;
}

QueueNode_ch * createQueueNode_ch( const char *data )
{
    QueueNode_ch *node = malloc( sizeof( QueueNode_ch ) );

    if ( node != NULL )
    {
        node->next = NULL;
        strcpy( node->data, data );
    }

    return node;
}

int enqueue_ch( Queue_ch *q, const char *data )
{
    int success = strlen( data ) < DATA_MAX + 1;

    if ( success )
    {
        QueueNode_ch *node = createQueueNode_ch( data );

        success = node != NULL;

        if ( success )
        {
            if ( q->rear == NULL )
            {
                q->front = q->rear = node;
            }
            else
            {
                q->rear = q->rear->next = node;
            }

            ++q->count;
        }
    }

    return success;
}

void deleteQueue_ch( Queue_ch *q )
{
    while ( q->front != NULL )
    {
        QueueNode_ch *node = q->front;
        q->front = q->front->next;
        free( node );
    }

    q->rear = q->front;
    q->count = 0;
}

int main(void) 
{
    Queue_ch queue;
    initQueue_ch( &queue );

    enqueue_ch( &queue, "hello" );

    deleteQueue_ch( &queue );

    return 0;
}

#包括
#包括
#包括
#定义数据_MAX 100
结构队列节点
{
结构QueueNode_ch*next；
字符数据[（数据_MAX+1）]；
};
typedef struct QueueNode_ch QueueNode_ch；
结构队列
{
结构QueueNode_ch*front；
结构QueueNode_ch*后部；
整数计数；
};
typedef struct Queue_ch Queue_ch；
void initQueue_ch（Queue_ch*q）
{
q->count=0；
q->front=NULL；
q->rear=NULL；
}
QueueNode_ch*createQueueNode_ch（常量字符*数据）
{
QueueNode_ch*node=malloc（sizeof（QueueNode_ch））；
如果（节点！=NULL）
{
节点->下一步=空；
strcpy（节点->数据，数据）；
}
返回节点；
}
int enqueue_ch（队列*q，常量字符*数据）
{
int success=strlen（数据）rear==NULL）
{
q->front=q->rear=node；
}
其他的
{
q->rear=q->rear->next=节点；
}
++q->计数；
}
}
回归成功；
}
无效删除队列（队列*q）
{
while（q->front！=NULL）
{
QueueNode\u ch*node=q->front；
q->front=q->front->next；
自由（节点）；
}
q->后=q->前；
q->count=0；
}
内部主（空）
{
队列；
初始化队列（队列和队列）；
排队等候（排队等候“你好”）；
删除队列（队列和队列）；
返回0；
}

函数

initQueue\u ch