标签: malloc

我正在尝试完成一些课堂示例，但遇到了以下问题：

阵列网格应具有长度宽度，每个条目代表一列单元格。有一些被占用的单元格的列应该是一个长度为高度的 malloc 字符数组。

使用给定的标题：

void grid(char **grid, int width, int height)

网格在另一个文件中定义为：

char **grid;

正如我所说，我一直坚持使用 malloc，我目前有：

int x;
*grid = malloc(width * sizeof(char));

        for(x = 0; x < width; x++){
            grid[x] = malloc(height * sizeof(char));
        }

任何人都可以看看给我一些关于正确方法的指针来完成“有一些被占用的单元格的列应该是一个长度为高度的 malloc'ed 字符数组。”，因为我不明白这一行：

grid[x] = malloc(height * sizeof(char));

相当于一个字符数组

谢谢

我目前有以下代码。

    struct qnode
    {
        char *path;
        struct qnode *next;
    }

    typedef struct qnode Node;

但是，当我尝试在 struct qnode 中为 for 分配空间时，我的代码此时失败了。

void add(Node *front, Node *back,char **path)
{
    /* Create the new node */
    Node *cur = (Node *)malloc(sizeof(Node));

    /* Verify node successfully created */
    if(cur)
    {
            /* Populate Members of Node */
            cur->path = malloc(strlen(*path)); /* fails here */
            printf("Malloc path success");
            cur->path = *path;

我已经验证 strlen 确实在正确的指针上运行并且它确实返回了大小的长度。出于某种原因，尽管此时我遇到了分段错误，但我不明白为什么。

仅供参考，这是分配的一部分，但是这条简单的 malloc 行不是专门分配的，也不是使用 C 语言。我被允许在作业中使用 C++，但我选择了 C 来获得更多关于该语言的知识。

谢谢您的帮助！

在一个简单的 C 程序中，如果我malloc有一个指向变量或数组的点，就内存映射而言，这部分内存分配到哪里？我对计算机编程很陌生，所以我不确定不同的变量在内存中的存储方式不同。

此外，全局变量（例如int x = 5）将存储在内存中的何处？

最后，有没有关于 C 语言如何与底层硬件交互的材料？我在网上找到的都是和C语法有关的，但是我太菜了，看不懂编译器的书。

如果这不清楚，请告诉我。

例如有一个链

class A
{
int a;
int b;
public:
A();
};

class B: public A
{
int c;
char b;
public:
B()
};

以普通的方式创建派生类的对象我们可以使用这种形式

A* ptr = new B()

如何使用 malloc 做同样的事情？

下面是一个直接变量声明的例子。

double multiplyByTwo (double input) {
  double twice = input * 2.0;
  return twice;
}

下面是一个动态内存分配的例子。

double *multiplyByTwo (double *input) {
  double *twice = malloc(sizeof(double));
  *twice = *input * 2.0;
  return twice;
}

如果我有选择，我会一直使用直接变量声明，因为代码看起来更易读。什么时候动态内存分配更合适？

遇到分段错误并且不明白为什么，必须传入三重指针进行赋值，因此无法更改...

这是功能

    void alloc2d(double*** a, int m, int n) {
     int i, j;

     **a  = malloc(sizeof(double *) * m);
     a[0] = malloc(sizeof(double) * n * m);

     for(i = 0; i < m; i++)
      a[i] = (*a + n * i);
    }

这是函数的调用...

double** m;
alloc2d(&m, 5, 10);

double count = 0.0;

for (int i = 0; i < 5; i++)
    for (int j = 0; j < 10; j++)
        m[i][j] = ++count;

for (int i = 0; i <  5; …

我不明白为什么这个简单的代码不会在 linux 上导致分段错误的情况下运行：

#include <stdlib.h>

struct entry
{
   int value;
};

void initEntry(struct entry *entry)
{
  entry = malloc(sizeof(struct entry));    
  entry->value = 0;
}

int main()
{
  struct entry *list;

  initEntry(list);    
  list->value = 5;
}

删除最后一条指令后我可以运行程序 ( list->value = 5;)

我编译：

gcc main.c -o main

我正在开发一个程序来解密文件中的某些文本行。首先，我创建的另一个源代码要求转换和一些文本。源代码加密文本并将其写入文件。

然后，我尝试使用以下代码（另一个源代码）解密指定的文件。获取文件名。从文件名获得移位。文件中写入的每个字符都被复制，在函数 caesar_decrypt -reversing caesar encrypt 的帮助下移动了 shift 的值，我也有。但是，给定的字符必须是 32 到 127 之间的 ascii 值才能转换为 32 到 127 之间的另一个 ascii 值字符。

我定义了我的模函数，它封装了余数运算符 - 正数的模 - 和负数的模。我还定义了 strip 函数，它的工作方式与 python 中的 strip 函数相同。除了空格，它会删除所有文字。我也有getIn()，它是python的input()。

我尝试通过打印和使用 gdb 进行调试。没有有效的结果。我在 stackoverflow 中研究过这个话题。找到一个条目。答案没有解决我的具体问题。

注意：我复制了整个程序，因为我认为您需要必要的详细信息。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>

/*GETIN FUNCTION*/
char* getIn() 
{
    char *line = NULL, *tmp = NULL;
    size_t size = 0, index = 0;
    int ch = EOF;

    while (ch) 
    {
        ch = getc(stdin);

        /* …

当我创建一个动态数组时：

int *arr = (int *) malloc( 4 * sizeof(int) );

所以它应该包含 4 个整数（对于空间问题可能还有 2 或 3 个），但为什么这样做：

    for ( int x = 0; x < 30000; x++) {
         arr[x] = x;
     }

我的意思是不应该有 30.000 个变量的空间，而且它工作得很好，可能是什么原因？它是否像 c++ std::vector 一样自动重新分配，或者我如何理解它？

如果我将循环范围设置为 50.000，它会崩溃，但它甚至应该像索引 a[100] 或之前那样崩溃，因为数组有 4 个元素。

如果这很重要，我正在使用 gnu/linux。

我非常努力地理解它。

请帮忙

我总是被告知释放由malloc()以下分配的堆内存：

#include <stdlib.h>

#define width 5

int main(void)
{
    char* ptr = malloc(sizeof(*ptr) * width);

    /* some stuff with the heap object */

    free(ptr);

    return 0;
}

但是现在我已经阅读了当您在 malloc 之后不释放时真正会发生什么？我不必这样做，因为操作系统会在程序终止后自动释放占用的内存。

但是当时为什么我的老师要我这样做呢？这样做有什么好处吗？