user2980746's questions

问题：如果我有一个指向“ints”结构的指针（如下所示），并且将其强制转换为 void 并返回，这是否意味着我不能再释放它了？free 如何跟踪分配大小？

typedef struct ints
{
    int size;              
    int *data;       
}
ints;

static void dev_array_cleanup(void *array, array_type type)
{
    switch(type)
    {
        case INT: 
        ints *i = (ints*) array; 
        free(i->data);
        free(i); 
        i = NULL; 
        break;
    }
}

static void* dev_array_set(void *array, int size, array_type type)
{
    void *p;

    switch(type) 
    {
        case INT: 
            ints *i = (ints*) malloc(sizeof(ints));
            i->size = size; 
            i->data = (int*) malloc(size * sizeof(int)); 
            p = (void*) i;
            break;
    }

    return p;
}

我有一个数据文件。

#version 460 core
out vec4 FragColor;

void main()
{
    FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
}

我正在尝试用 fread 读取其中的内容。

    FILE *fshader;
    char *fbuffer;
    long fsize;

    fshader = fopen("src/graphics/_fragment.shader", "r");

    fseek(fshader, 0L, SEEK_END); 
    fsize = ftell(fshader); 
    rewind(fshader);

    fbuffer = (char *)malloc(fsize + 1);
    fread(fbuffer, 1, fsize, fshader); 
    fbuffer[fsize] = '\0';

但我不明白 fread 是如何工作的。它总是读取比应读取的多 6 个字符。

#version 460 core
out vec4 FragColor;

void main()
{
    FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);
}_to_te

我是 C 语言的新手，被这个问题难住了。在 C# 中，做这样的事情完全没问题，但在 C 中，编译器的工作方式不同，它需要事先知道类型定义。

struct FN;

typedef struct {
    void (*create) (FN *fn);
} Window;

typedef struct {
    Window window;
} FN;

是否有某种 C 技巧与指针等可以让我使用它来使其工作？我正在尝试创建一个“管理器”类，在其中我可以调用模块上的函数，然后将管理器传递到需要的地方。

如果我像这样构建我的 C 程序，随着项目的增长，编译时间是否会减少？

#include <stdio.h>
#include "lib/manager/manager.h"
#include "lib/loop/loop.h"
#include "lib/utility/utility.h"

int main()
{
    FN fn;
    dev_loop_init(&fn);
    dev_utility_init(&fn);

    fn.util.log("test");

    return 0;
}

我将在每个“模块”中包含一个 manager.h 头文件。

#ifndef DEV_MANAGER
#define DEV_MANAGER

typedef struct {
    void (*start) (void);
    void (*stop) (void);
} Loop;

typedef struct {
    void (*log) (char* message);
} Utility;

typedef struct {
    Loop loop;
    Utility util;
} FN;

#endif

一个示例模块，loop.h。

#include "../manager/manager.h"

#ifndef DEV_LOOP
#define DEV_LOOP

void dev_loop_init(FN *fn);

#endif

loop.c 函数

#include "loop.h"

static void dev_loop_start(){}

static void dev_loop_stop(){}

void dev_loop_init(FN *fn)
{
    fn->loop.start = &dev_loop_start;
    fn->loop.stop = &dev_loop_stop;
}

你们会用这种方式在 C 中创建“类”吗？那么接口呢？我猜我们只是对所有东西都使用函数指针，并且可以更改函数指针指向的位置？

#ifndef CLASS
#define CLASS

void method1() { printf("method #1"); }
void method2() { printf("method #2"); }

typedef struct {
    void (*method1)(void);
    void (*method2)(void);
} Class;

Class class;

void class_setup()
{
    class.method1 = &method1;
    class.method2 = &method2;
}

#endif

int main()
{
    class_setup();

    class.method1();
    class.method2();

    return 0;
}

不知道这叫什么，但当你点击编辑器中的各个部分时，就会弹出蓝色框。有什么办法可以删除它吗？不知道他们为什么要默认放这么烦人的东西。

这里有一些填充文字来描述随处弹出的烦人的蓝色框。

我不确定这是否可能，但我有几个不同值类型的字典。

public Dictionary<int, Type1> type1;
public Dictionary<int, Type2> type2;

我希望能够使用泛型来获取特定类型的对象。

public T Get<T>(int ID)
{
    // somehow find the correct dictionary and return its value
}

我可以使用 switch 语句，但是有没有更聪明的方法？

这可能是一个非常简单的愚蠢问题，但我只需要一些帮助来理解它。我将一个结构存储在字典中，我想抓住该结构更改一些值，然后让它在字典中自动更新，但行为很奇怪。

public struct Test
{
    public int a;
}

public class Tester
{
    public static Dictionary<int, Test> d = new Dictionary<int, Test>();

    public static bool GetTest(int position, out Test test)
    {
        if (d.ContainsKey(position)) {
            test = d[position];
            return true;
        } else {
            test = new Test();
            return false;
        }
    }
}

当我尝试从字典中获取结构并更改值时，它不会更新。

        Test n = new Test();
        n.a = 10;
        Tester.d.Add(n.a, n);

        Tester.GetTest(10, out Test t1);
        Debug.Log(t1.a);

        t1.a = 20;

        Tester.GetTest(10, out Test t2);
        Debug.Log(t2.a);

一直显示 10。所以当我使用该out参数时，它会复制字典中的结构并返回该结构？所以我需要再写一行来再次更新字典，对吗？

有什么简单的方法可以抓取结构并只在字典中更新其值而不添加额外的行？

编辑：

我可以做到这一点...

Tester.d[position].a = 20;

但是有没有办法用一种方法来实现这一点？在哪里我可以获取整个结构，编辑一个值，然后它会自动在字典中更新？抱歉问了个愚蠢的问题，我只是不明白这种行为。