Question

为了便于打印，我想创建一个指向我的struct元素的指针数组。我怎样才能做到这一点？我的尝试是在结构的最后一行。就像一个注释，这个结构有除int之外的其他值，现在在这里显示。我希望这种索引只针对整数。

struct status {
    int lastinputVac;
    int inputVac;

    int outputVac;

    /* The unit is % */
    int outputpower;

    int outputHz;

    /* The unit is % */
    int batterylevel;

    int temperatureC;

    int *ordered_values[] = { &lastinputVac, &inputVac, &outputVac, &outputpower, &outputHz, &batterylevel, &temperatureC };
}

Answer 1

只需咬紧牙关并编写额外的代码，然后使用struct member access打印它。保存几行代码并不值得牺牲您的设计。

想象一下，有一天你必须在库中公开这个结构。你真的想用这个奇怪的指针数组加载用户吗？这个数组没有用处？

Answer 2

所以问题是“我想创建一个指向我的struct元素的指针数组。”并提到元素可能不是int。

我写了一个通用解决方案，在安全性或语言一致性和设计方面可能还需要很多改进，但它显示了下面问题的一个解决方案。下面的代码计算结构的大小，假设结构的元素大小相同，然后构造一个指向元素的指针数组，print_array函数通过打印出来迭代这些元素。我本可以超载ostream＆lt;＆lt;也是运营商，但我希望尽可能地保持这种简单。

  #include "stdafx.h"

  struct status {
      int lastinputVac;
      int inputVac;
      int outputVac;

      /* The unit is % */
      int outputpower;

      int outputHz;

      /* The unit is % */
      int batterylevel;

      int temperatureC;
};

//template<typename T>
#include <vector>
#include <algorithm>
#include <iostream>
#include <iterator>

// hide this into a library 
template<typename T>
size_t build_array(const status& val, T*** vecptr)
{
const size_t _size = sizeof(status) / sizeof(int);
*vecptr = (T**)malloc( sizeof(T*) *_size );

for (size_t i = 0; i < _size; ++i) {
    (*vecptr)[i] = ((T *)((&val)+i));
}
return _size;
}

template<typename T>
void free_array(T** vecptr)
{
free(vecptr);
}

template<typename T>
void print_array(T **vecptr, size_t size) 
{
for (size_t i = 0; i < size; i++)
    std::cout << *(*vecptr + i) << std::endl;
}

//T1 is the type of the struct and T2 is the type of the elements
template<typename T1, typename T2>
class PrintStruct
{
private:
    T2 **m_vecptr;
    size_t m_size;

public:
    PrintStruct(T1 t) {
        m_size = build_array<T2>(t, &m_vecptr);
        print_array(m_vecptr, m_size);
    }

    ~PrintStruct() {
        free_array(m_vecptr);
    }
 };

 int _tmain(int argc, _TCHAR* argv[])
 {
 status _status;
 _status.batterylevel = 1;
 _status.inputVac = 2;
 _status.lastinputVac = 3;
 _status.outputHz = 4;
 _status.outputpower = 5;
 _status.outputVac = 6;
 _status.temperatureC = 7;

 PrintStruct<status, int> _ps(_status);
 return 0;
 }

Answer 3

这种方式是不可能的。

在C ++中有一个成员指针（“相对”指针）的概念，这正是你真正需要的。

在你的情况下和C我会建议总是使用一组int来命名索引

struct status {
   int values[7];
}
..
const int lastinputVac = 0;  // or upper case when you like, or use #define
..
status a;
a.values[lastinputVac] = 27;
int z = a.values[lastinputVac];

你明白了吗？

顺便说一下，你可以用联盟做两种方法，提供带有名称的编译访问权限和通过数组索引的方式

Answer 4

您无法独立于结构变量实例获取结构成员的地址; IOW，你必须做类似

的事情

struct status foo;
int *ordered_values[] = {&foo.lastInputVac, &foo.inputVac, ...};

但是，鉴于您的所有结构成员都是int s，您可以做一些类型投注 a la

int *ordered_values = (int *) &foo;
for (i = 0; i < 7; i++)
  printf("%d\n", ordered_values[i]);

这个应该工作; struct实例的地址与其第一个成员的地址相同，并且由于所有成员都是int s，因此不应存在任何对齐或填充问题。我不推荐这种做法，但为了你的目的，它应该运作良好。

Answer 5

通过阅读你的评论，看起来你有很多结构元素，但你只想打印一些。以下是我的想法：

1）不要把这个数组放在struct中！它是静态的 - 对于任何struct status它都不会改变，因此在结构中使用它是浪费和不直观的。

2）您是否考虑过将这些值分离到自己的结构中？然后，您可以使用以下范例：

enum status {
    LASTINPUT_VAC,
    INPUT_VAC,
    OUTPUT_VAC,
    OUTPUT_PWR,
    OUTPUT_HZ,
    BATT_LVL,
    TEMPERATURE,
    STATUS_MAX
};

struct system {
    char name[MAXNAME];
    long other_data;
    float coords[2];
    char *whatever_you_have_here;
    int status[STATUS_MAX];
};

然后打印/使用您通过以下方式引用它：

struct system sys;
int temp = sys.status[TEMPERATURE];
for (int i = 0; i < STATUS_MAX; i++)
    printf("%d\n", sys.status[i]);

这可能不符合您的确切需求，但我只是想把它放在那里作为另一种方式，您可以在C中做这种事情！干杯！

Answer 6

我脑子里还有另一种方法。我的观察是，成员的顺序是正确的，但您可能希望通过索引轻松访问。

但警告：你必须关心填充。填充可能会导致整数错位。但是，在int32的情况下，我认为没问题。

有些人会认为这太过于hacky，但是，这是一种可能性

struct status {
  int lastinputVac;
  int inputVac;

  int outputVac;

/* The unit is % */
  int outputpower;

  int outputHz;

  /* The unit is % */
  int batterylevel;

  int temperatureC;
} stat;

int* a = &stat;

int maxIndex = (&stat.temperatureC - &stat.lastinputVac) / sizeof (stat); // should be 6
 // you could build named constants for that
a[0]; // lastinputVac
a[1]; // inputVac
a[2]; // outputVac
a[3]; // outputpower
a[4]; // outputHz
a[5]; // batterylevel
a[6]; // temperatureC

Answer 7

使用数组联合struct。请参阅有关对齐的编译器文档。

union {

    struct {
       int someInt0;
       int someInt1;    
    }; //anonymous

    int arry[2];

} thing;

〜

val0 = thing.someInt0; //structure access
val1 = thing.arry[0]; //gcc, C18, XC8, and XC32 handle this with the top value indexed to 0

if (val0 == val1) { 
    puts("this works");
}

C：指向struct中struct元素的指针

7 个答案: