如何在 C++ 中制作与 Delphi 中类似的结构

Question

My program is receiving messages by WM_COPYDATA containing a pointer to structure which looks in Delphi like this:

type
  arr_geo_t = array[0..5000] of packed record
    nr : string[15];
    x,y,h : double;
    k : string[10];
  end;
  parr_geo_t = ^arr_geo_t;

The question is, how to make a similar one in C++?

When I define something like this:

typedef struct
{
    char nr[5000][15];
    double x[5000];
    double y[5000];
    double h[5000];
    char k[5000][10];
} arr_geo_t, *parr_geo_t;

and try to retrieve data, I get nothing.

Answer 1

In the Delphi code, arr_geo_t is an array of records of anonymous type, not a record of arrays, like you declared in your C++ code. The correct C++ translation of the Delphi declarations would look more like this:

#include <pshpack1.h> // #pragma pack(push, 1), etc
typedef struct
{
    char nr[16];
    double x,y,h;
    char k[11];
} arr_geo_t[5001];
#include <poppack.h> // #pragma pack(pop), etc

typedef arr_geo_t *parr_geo_t;

Note that Delphi array ranges are inclusive, so 0..5000 denotes 5001 elements indexed from index 0 to index 5000, inclusive.

Also note that the char[] arrays have 1 more char in them that you are not taking into account. That is because in Delphi, a string[N] is a ShortString , an AnsiChar -based fixed length string type where N is the maximum number of AnsiChar s allowed, and is prefixed by 1 AnsiChar specifying how many actual AnsiChar s are in the string. The string length is at index 0, and the character data begins at index 1.

If you are translating the Delphi code to C++Builder specifically, you can use the SmallString template instead of char[] arrays:

#include <System.hpp>

#include <pshpack1.h> // #pragma pack(push, 1), etc
typedef struct
{
    System::SmallString<15> nr;
    double x,y,h;
    System::SmallString<10> k;
} arr_geo_t[5001];
#include <poppack.h> // #pragma pack(pop), etc

typedef arr_geo_t *parr_geo_t;

If you translate to C++11 or later, you can clean up the typedef s via using statements instead:

#include <array>
//#include <System.hpp>

#include <pshpack1.h> // #pragma pack(push, 1), etc
struct arr_geo_data_t
{
    std::array<char, 16> nr; // or: System::SmallString<15> nr;
    double x,y,h;
    std::array<char, 11> k; // or: System::SmallString<10> k;
};
#include <poppack.h> // #pragma pack(pop), etc

using arr_geo_t = std::array<arr_geo_data_t, 5001>;
using parr_geo_t = arr_geo_t*;

Answer 2

There is an ordering issue here. You have an array of a structure, not a number of arrays of data members.

I think you may find that the following is a closer match, but I'm sorry delphi internal types are no longer important to me!

struct arr_geo_t 
{
  struct record 
  {
    char nr[15];
    double x,y,h;
    char k[10];
  } array[5001];

};

Note also that I don't know how well packed record works in delphi. c/c++ will ensure that the doubles are aligned on 8 byte boundaries, effectively expanding nr to 16 characters, for example. The whole structure will also be aligned to 8 byte boundaries, so k will have an effective size of 16 as well. On some computers, and with some compiler settings, doubles simply cannot be accessed from unaligned addresses.

That is assuming delphi strings are char based and not unicode based.