如何在内存位置获取对象？

Question

如果我的内存位置存储在整数中，我如何才能将对象存储在内存位置？

我需要如何使用它：

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

/*
 Stride: The size of the data structure containing the per-vertex data
 Offset: Offset within the structure to find this data
 */

// Example structs that store the data
typedef struct {
    float x;
    float y;
    float z;
} Vertex;

typedef struct {
    float x;
    float y;
    float z;
} Normal;

typedef struct {
    float r;
    float g;
    float b;
} Color;

// Info for rendering
typedef struct {
    int vertex;
    int vertexStride;
    int vertexOffset;
    int normal;
    int normalStride;
    int normalOffset;
    int index;
} RenderData;


RenderData _renderData;
int _buffer; // Memory location of array with data

// sets the integer to the memory location of the data
void celBindBuffer(int *buffer)
{
    _buffer = &buffer; // Alert:Incompatible pointer to integer conversion assigning to 'int' from 'int **'
}

void celVertexAttribPointer(CelVertexAttrib attrib, int stride/*bytes*/, int offset/*bytes*/)
{
    switch (attrib) {
        case CelVertexAttribPosition:
            _renderData.vertex = _buffer;
            _renderData.vertexStride = stride;
            _renderData.vertexOffset = offset;
            break;
        case CelVertexAttribNormal:
            _renderData.normal = _buffer;
            _renderData.normalStride = stride;
            _renderData.normalOffset = offset;
        default:
            break;
    }
}

void printVertex(Vertex v)
{
    printf("Vertex[%f,%f,%f]\n", v.x, v.y, v.z);
}

void testPrint(int size/*size in bytes*/)
{
    for (int i = 0; i < size; i++) {
        // Gets the initial location of the data in which it is stored, gets the size of the struct and multiplies it by the index and then offsets to the 
        Vertex v = (Vertex)(_renderData.vertex + i * _renderData.vertexStride + _renderData.vertexOffset); // How can I do this?
        printVertex(v);
    }
}

我应该如何在该位置获取对象，为什么我会在 _buffer = &buffer; 收到警告？

编辑： 变量缓冲区是一个结构数组，而不仅仅是一个值，所以我需要它的内存位置。一旦我有了那个，我怎样才能在那个位置接收对象（线路：Vertex v = (Vertex)(_renderData.vertex + i * _renderData.vertexStride + _renderData.vertexOffset);）？

编辑： 所以要获取数据的位置，我会使用 _buffer = &(*buffer); 吗？

编辑 传递给方法的信息：

typedef struct {
    Vertex position;
    Normal normal;
} VertexData;

static const VertexData mesh[] = {
    {/*v:*/{-0.000000, -1.125000, 0.000000}, /*n:*/{0.059877, -0.998169, 0.007874} },
    {/*v:*/{-0.000000, -0.986528, -0.475087}, /*n:*/{0.114078, -0.863674, -0.490890} },
    {/*v:*/{0.357184, -0.948670, -0.284845}, /*n:*/{0.427045, -0.850368, -0.307321} },
    {/*v:*/{-0.000000, -1.125000, 0.000000}, /*n:*/{0.059877, -0.998169, 0.007874} },
    {/*v:*/{0.357184, -0.948670, -0.284845}, /*n:*/{0.427045, -0.850368, -0.307321} },
    {/*v:*/{0.449795, -0.958029, 0.102663}, /*n:*/{0.477462, -0.877438, 0.045442} },
    {/*v:*/{-0.000000, -1.125000, 0.000000}, /*n:*/{0.059877, -0.998169, 0.007874} },
    {/*v:*/{0.449795, -0.958029, 0.102663}, /*n:*/{0.477462, -0.877438, 0.045442} },
        ...
};

void render() {
    celBindBuffer(mesh);
    celVertexAttribPointer(CelVertexAttribPosition, sizeof(VertexData), offsetof(VertexData, position));
    testPrint(sizeof(mesh) / sizeof(VertexData));
}

Answer 1

指针 (int *buffer) 是一个包含内存地址的变量。在指针指向的地址处读取内存称为解引用指针。您正在做的实际上是获取指针本身的地址。所以不要这样：

_buffer = &buffer;

.. 您必须取消引用指针才能读取此 buffer 指针指向的值：

_buffer = *buffer;

我建议你阅读Pointer Basics 文章，它可以帮助你稍微了解一下这些东西。

希望对您有所帮助。祝你好运！

更新：

在您的情况下，最好使用与传入的对象相同类型的指针。否则会很混乱。这是使用该指针的示例：

#include <stdio.h>

typedef struct {
    double x;
    double y;
    double z;
} Vertex; /* Just to make a simple code compile.. */
typedef Vertex Normal; /* Same story... */

typedef struct {
    Vertex position;
    Normal normal;
} VertexData;

static const VertexData mesh[] = {
    { {-0.000000, -1.125000, 0.000000}, {0.059877, -0.998169, 0.007874} },
    { {-0.000000, -0.986528, -0.475087}, {0.114078, -0.863674, -0.490890} },
    { {0.357184, -0.948670, -0.284845}, {0.427045, -0.850368, -0.307321} },
    { {-0.000000, -1.125000, 0.000000}, {0.059877, -0.998169, 0.007874} },
    { {0.357184, -0.948670, -0.284845}, {0.427045, -0.850368, -0.307321} },
    { {0.449795, -0.958029, 0.102663}, {0.477462, -0.877438, 0.045442} },
    { {-0.000000, -1.125000, 0.000000}, {0.059877, -0.998169, 0.007874} },
    { {0.449795, -0.958029, 0.102663}, {0.477462, -0.877438, 0.045442} }
};

void celBindBuffer(const VertexData *data)
{
    const Vertex *v0 = &data[0].position;
    const Normal *n0 = &data[0].normal;

    const Vertex *v1 = &data[1].position;
    const Normal *n1 = &data[1].normal;

    printf("Vertex#1: %f/%f/%f...\n", v0->x, v0->y, v0->z);
    printf("Vertex#2: %f/%f/%f...\n", v1->x, v1->y, v1->z);
}

int main(void)
{
    celBindBuffer(mesh);
    return 0;
}

如您所见，一点点 pointer arithmetics 就可以完成这项工作。 但是，您的函数存在一些问题 - 您尝试做的是传递一个 VertexData 对象数组。但问题是函数celBindBuffer() 不知道该数组中有多少元素......您必须将一个数字传递给该函数以告知向量中有多少元素。否则你很容易遇到undefined behavior。

Answer 2

线

_buffer = &buffer;

正在尝试将变量buffer（恰好是一个指针）的地址分配给整数变量_buffer。换句话说，它将“指向指针的指针”类型分配给一个整数变量。 （& 运算符的意思是“地址”。）你可能想要

_buffer = *buffer;

它将buffer（将是一个整数）中地址的内容分配给整数_buffer。 * 运算符表示“此地址的内容”。