C : 为一个函数参数发送不同的结构 [英] C : send different structures for one function argument

问题描述

我有一个使用 OpenGL 绘制圆的函数，我想向它传递一个包含 x 和 y 坐标以及半径的结构.问题是这个相同的函数必须与 3 个不同的结构一起使用，所有结构都包含坐标、半径和绘图函数不使用的其他一些东西.

I have a function that draws a circle using OpenGL, I would like to pass it a structure containing the x and y coordinates and the radius. The problem is this same function has to be used with 3 different structures all containing the coordinates, radius and some other things that the draw function doesn't use.

有没有办法让 3 个不同的结构只有一个参数(一次只发送一个).

Is there some way to only have one argument for 3 different structures (only one is sent at a time).

我希望我已经足够精确了.

I hope I've been enough precise.

PS:函数必须是抽象的".

PS : the functions have to be "abstract".

推荐答案

是的，你可以使用这样的原型:

Yes you can use a prototype like this:

void foo(char type, void *data);

使用类型告诉函数将数据用作哪个结构，你就很好.

Use the type to tell the function which struct to use the data as, and you're good.

struct c *prepareStructC(void);
//...
struct c *toto = prepareStructC();
foo('c', toto);
//...
void foo(char type, void *data)
{
  int x, y;
  switch (type)
  {
    case 'c':
      x = ((struct c*)data)->x;
      y = ((struct c*)data)->y;
      break;
    //...
  }
  //...
}

第二个选项，如果您想避免 switch/case，并且能够在之后添加更多结构类型，而无需演变 foo，您可以确保所有结构开始都具有必要的数据，总是以相同的顺序，具有相同的类型.通过这种方式，您可以从 C++ 中创建类似接口"的东西，并使用该类型的抽象版本:

Second option, if you want to avoid a switch/case, and be able to add more struct types afterwards, without evolving foo, you can make sure all your structs begin with the necessary data, always in the same order, with the same type. This way you can make something like an "interface" from C++, and use abstract versions of the type:

struct abstract
{
  int x;
  int y;
  int radius;
}

struct a
{
  struct abstract abs;
  //... other data ...
}
struct b
{
  struct abstract abs;
  //... other data ...
}
struct c
{
  struct abstract abs;
  //... other data ...
}

//Two choices : either you have:
void foo(void *data)
{
  int x,y,r;
  x = ((struct abstract*)data)->x;
  y = ((struct abstract*)data)->y;
  r = ((struct abstract*)data)->radius;
  //...
}

//OR Smarter way:
void foo2(struct abstract *data)
{
  int x,y,r;
  x = data->x;
  y = data->y;
  r = data->radius;
}
//Calling foo2 with:
struct a *sa = prepareStructA();
struct b *sb = prepareStructB();
struct c *sc = prepareStructC();
foo2(sa->abs);
foo2(sb->abs);
foo2(sc->abs);

第二种方法的第二部分让你更灵活，分解子类型中的特定信息，使你可以将 abs 部分放在结构 a/b/c 内的任何位置，并且更好遵循结构单一目的的原则(在结构内具有坐标和半径和其他东西并不总是最好的.)

The second part of the second method allows you more flexibility, breaking down specific information in a subtype, enables you to put the abs part anywhere inside the struct a/b/c, and is better in the principle of a single purpose for a struct (Having coordinates and radius and other things inside a struct is not always the best.)

这篇关于C : 为一个函数参数发送不同的结构的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！