Сериализируйте Строки, ints и плавания к символьным массивам для сетей БЕЗ БИБЛИОТЕК
Статическое объявление на этом уровне кода означает, что переменная только видима в текущей единице компиляции. Это означает, что только кодируют в том модуле, будет видеть ту переменную.
, если у Вас есть заголовочный файл, который объявляет, переменные помехи и тот заголовок включены в несколько файлов C/CPP, тогда та переменная будет "локальна" для тех модулей. Будут копии N той переменной для мест N, что заголовок включен. Они не связаны друг с другом вообще. Любой код в любом из тех исходных файлов только сошлется на переменную, которая объявляется в том модуле.
В данном случае, 'статическое' ключевое слово, кажется, не предоставляет преимущества. Я мог бы пропускать что-то, но это, кажется, не имеет значение - я никогда не видел ничего сделанного как это прежде.
Что касается встраивания, в этом случае переменная, вероятно, встраивается, но это - то, только потому, что это объявило константу. Компилятор мог бы для, более вероятно, встраивания статических переменных модуля, но это зависит от ситуации и скомпилированного кода. Нет никакой гарантии, что компилятор встроит 'помехи'.
4 ответа
Ах, вы хотите сериализовать примитивные типы данных! В принципе, существует два подхода. Первый заключается в том, что вы просто берете внутреннее двоичное представление данных, которые хотите сериализовать, в памяти, интерпретируете его как символ и используете его в качестве представления:
Итак если у вас есть:
double d;
, вы берете его адрес, интерпретируете этот указатель как указатель на символ, а затем используете эти символы:
double *pd=&d;
char *pc = reinterpret_cast<char*>(pd);
for(size_t i=0; i<sizeof(double); i++)
{
char ch = *pc;
DoSomethingWith(ch);
pc++;
}
Это работает со всеми примитивными типами данных. Основная проблема здесь в том, что представление binray зависит от реализации (в основном зависит от процессора). (И вы столкнетесь с небольшими ошибками, когда попытаетесь сделать это с IEEE NAN ...)
В общем, этот подход вообще не переносим, так как у вас нет никакого контроля над представлением ваших данных.
Второй подход заключается в использовании представления более высокого уровня, которое вы сами контролируете. Если производительность не является проблемой, вы можете использовать std :: strstream и операторы >> и << для потоковой передачи примитивных переменных типа C в std :: strings. Это медленно, но легко читается и отлаживается, а также очень переносимо.
(И вы столкнетесь с небольшими ошибками, когда попытаетесь сделать это с IEEE NAN ...)В общем, этот подход вообще не переносим, так как у вас нет никакого контроля над представлением ваших данных.
Второй подход заключается в использовании представления более высокого уровня, которое вы сами контролируете. Если производительность не является проблемой, вы можете использовать std :: strstream и операторы >> и << для потоковой передачи примитивных переменных типа C в std :: strings. Это медленно, но легко читается и отлаживается, а также очень переносимо.
(И вы столкнетесь с небольшими ошибками, когда попытаетесь сделать это с IEEE NAN ...)В общем, этот подход вообще не переносим, так как у вас нет никакого контроля над представлением ваших данных.
Второй подход заключается в использовании представления более высокого уровня, которое вы сами контролируете. Если производительность не является проблемой, вы можете использовать std :: strstream и операторы >> и << для потоковой передачи примитивных переменных типа C в std :: strings. Это медленно, но легко читается и отлаживается, а также очень переносимо.
вы можете использовать std :: strstream и операторы >> и << для потоковой передачи примитивных переменных типа C в std :: strings. Это медленно, но легко читается и отлаживается, а также очень переносимо. вы можете использовать std :: strstream и операторы >> и << для потоковой передачи примитивных переменных типа C в std :: strings. Это медленно, но легко читается и отлаживается, а также очень переносимо.Это обсуждение кажется относящимся к вашему вопросу, но оно использует API ускоренной сериализации
Что-то вроде приведенного ниже кода подойдет. Остерегайтесь проблем, когда sizeof (unsigned int) отличается в разных системах, это поможет вам. Для подобных вещей лучше использовать типы с четко определенными размерами, например int32_t. В любом случае ...
unsigned int x = 123;
char y[3] = {'h', 'i', '\0'};
float z = 1.23f;
// The buffer we will be writing bytes into
unsigned char outBuf[sizeof(x)+sizeof(y)+sizeof(z)];
// A pointer we will advance whenever we write data
unsigned char * p = outBuf;
// Serialize "x" into outBuf
unsigned int32_t neX = htonl(x);
memcpy(p, &neX, sizeof(neX));
p += sizeof(neX);
// Serialize "y" into outBuf
memcpy(p, y, sizeof(y));
p += sizeof(y);
// Serialize "z" into outBuf
int32_t neZ = htonl(*(reinterpret_cast<int32_t *>(&z)));
memcpy(p, &neZ, sizeof(neZ));
p += sizeof(neZ);
int resultCode = send(mySocket, outBuf, p-outBuf, 0);
[...]
... и, конечно же, принимающий код будет делать что-то подобное, только наоборот.
Какова ваша цель? И какие именно средства вы готовы использовать?
Если вы просто хотите выполнить работу с одним конкретным компилятором на одном конкретном компьютере, то самым быстрым и простым, но также и самым грязным решением является использование союз. Вы определяете структуру, в которой ваши элементы являются членами, и объединяете ее с массивом символов. Вам нужно сказать компилятору, что нужно плотно упаковать элементы, что-то вроде #pragma pack (1), и ваша проблема будет решена. Вы просто сохраняете три значения в членах, а затем смотрите на них как на массив символов.
Если машина работает с прямым порядком байтов, и вам нужны целые числа и числа с обратным порядком байтов, вы просто меняете соответствующие символы местами.
Но есть по крайней мере еще дюжина решений, которые приходят на ум, если у вас есть другие цели, например переносимость,