#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> int main(void) { char* cp; char symbol; int num; printf("enter how many symbols\n"); scanf("%c%d", &symbol, &num); cp = (char*)malloc(num * sizeof(char)); if (cp == NULL) { printf("memory allocation failed\n"); return -1; } cp[0] = symbol; printf("%c ", cp[0]); return 0; }+ cp 0x00000000177c54e0 <读取字符串字符时出错。> char *

这段代码在运行时发生了访问非法内存的错误，原因是在调用`scanf`读取输入时，输入的第一个字符被当做换行符读取了，导致后续的内存分配和操作出现问题。

为了解决这个问题，可以在读取输入之前先读取并丢弃输入缓冲区中的换行符。可以在`scanf`调用之前，使用一个额外的`getchar`函数来读取并丢弃换行符。修改后的代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main(void) {
    char* cp;
    char symbol;
    int num;
    printf("enter how many symbols\n");
    getchar(); // 读取并丢弃输入缓冲区中的换行符
    scanf("%c%d", &symbol, &num);
    cp = (char*)malloc(num * sizeof(char));
    if (cp == NULL) {
        printf("memory allocation failed\n");
        return -1;
    }
    cp[0] = symbol;
    printf("%c ", cp[0]);
    return 0;
}

这样可以避免访问非法内存的错误，并正确读取输入。

相关问题

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #define N 3 void fun(int a[][N], int m) { for (int i = 0; i < N; i++) { for (int j = N - 1; j >= i; j--) { a[i][j] = a[i][j] * m; } } } int main() { int m = 0; scanf("%d", &m); int a[][N] = { {1,9,7},{2,3,8},{4,5,6} }; fun(a, m); for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { printf("%d ", a[i][j]); } printf("\n"); } return 0; }该代码运行流程

该代码的运行流程如下：

1. 引入头文件 `stdio.h` 和 `string.h`，并定义宏 `_CRT_SECURE_NO_WARNINGS`。

2. 定义常量 `N` 为 3，表示二维数组的维度。

3. 定义函数 `fun(int a[][N], int m)`，该函数的作用是将二维数组 `a` 中每个元素乘以 `m`。

4. 在 `fun` 函数中，使用双重循环遍历二维数组 `a`，从右上角开始，对每个元素乘以 `m`。

5. 在 `main` 函数中，定义变量 `m` 并从控制台读入一个整数。

6. 定义二维数组 `a` 并初始化为一个 3x3 的矩阵。

7. 调用函数 `fun` 将二维数组 `a` 中的每个元素乘以 `m`。

8. 使用双重循环遍历二维数组 `a`，并在控制台上输出每个元素的值。

9. 程序结束，返回 0。

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<windows.h> #include<string.h> #include<stdlib.h> #include<math.h> #include<malloc.h> typedef struct character_name { char name[100]; struct character_name* next; }char_name; typedef struct character_title { char title[100]; struct character_title* next; }char_title; typedef struct character_identity { char identity[100]; struct character_identity* next; }char_iden; typedef struct character_attribute { int strength; struct character_attribute* next; }char_att; typedef struct character_information { char_name* _name; char_title* _title; char_iden* _iden; char_att* _att; struct character_information* next; }char_inf; void initialization(char_inf*node) { node = (char_inf*)malloc(sizeof(char_inf)); node->_name = (char_name*)malloc(sizeof(char_name)); node->_title = (char_title*)malloc(sizeof(char_title)); node->_iden = (char_iden*)malloc(sizeof(char_iden)); node->_att = (char_att*)malloc(sizeof(char_att)); } char_inf* ceshi; int main() { initialization(ceshi); strcpy(ceshi->_name->name, "ceshi_1"); strcpy(ceshi->_title->title, "ceshi_2"); strcpy(ceshi->_iden->identity, "ceshi_3"); ceshi->_att->strength = 4; printf("%s\n%s\n%s\n%d\n", ceshi->_name->name, ceshi->_title->title, ceshi->_iden->identity, ceshi->_att->strength); return 0; } 为什么报错访问权限冲突

在你的代码中，报错访问权限冲突是因为你在初始化函数`initialization`中使用了错误的方式来分配内存。具体来说，你传递了一个指向`char_inf`结构体指针的指针（`char_inf* node`），然后在函数内部尝试为它分配内存。

然而，这样的分配方式是错误的，因为当你在函数内部为`node`分配内存时，它只是一个局部变量，对外部的`ceshi`指针没有影响。因此，在`main`函数中访问`ceshi`时，它仍然是一个未初始化的指针，导致访问权限冲突。

为了解决这个问题，你可以将`initialization`函数修改为返回分配好的内存块的指针，然后将其赋值给`ceshi`指针。具体代码如下所示：

char_inf* initialization()
{
    char_inf* node = (char_inf*)malloc(sizeof(char_inf));
    node->_name = (char_name*)malloc(sizeof(char_name));
    node->_title = (char_title*)malloc(sizeof(char_title));
    node->_iden = (char_iden*)malloc(sizeof(char_iden));
    node->_att = (char_att*)malloc(sizeof(char_att));
    return node;
}

然后在`main`函数中调用该函数，并将返回的指针赋值给`ceshi`，如下所示：

ceshi = initialization();

这样，你就可以正确地分配内存并访问`ceshi`结构体的成员了，不再会出现访问权限冲突的错误。