Безопасен этот прием инициализации структуры C++?

Это заставило бы меня чувствовать себя намного более в безопасности, поскольку это должно работать, даже если существует vtable (или компилятор будет кричать).

memset(static_cast<MY_STRUCT*>(this), 0, sizeof(MY_STRUCT));

я уверен, что Ваше решение будет работать, но я сомневаюсь, что существуют любые гарантии, которые будут сделаны при смешивании memset и классы.

Намного лучше, чем memset, можно использовать этот небольшой прием вместо этого:

MY_STRUCT foo = { 0 };

Это инициализирует всех участников к 0 (или их значение по умолчанию iirc), никакая потребность к specifiy значение для каждого.

С точки зрения C++ ISO существует две проблемы:

(1) объект POD? Акроним обозначает Простые Данные, и стандарт перечисляет то, что Вы не можете иметь в POD (Википедия имеет хорошую сводку). Если это не POD, Вы не можете memset это.

(2) там участники, для которых все-нуль битов недопустим? В Windows и Unix, Нулевой указатель является всем нулем битов; это не должно быть. Плавающая точка 0 имеет весь нуль битов в IEEE754, который довольно распространен, и на x86.

подсказка Frank Kruegers обращается к Вашим проблемам путем ограничения memset основой POD класса не-POD.

Попробуйте это - новая перегрузка.

РЕДАКТИРОВАНИЕ: Я должен добавить - Это безопасно, потому что память обнуляется, прежде любой конструкторов вызывают. Большой дефект - только работает, если объект динамично выделяется.

struct MY_STRUCT
{
    int n1;
    int n2;
};

class CMyStruct : public MY_STRUCT
{
public:
    CMyStruct()
    {
        // whatever
    }
    void* new(size_t size)
    {
        // dangerous
        return memset(malloc(size),0,size);
        // better
        if (void *p = malloc(size))
        {
            return (memset(p, 0, size));
        }
        else
        {
            throw bad_alloc();
        }
    }
    void delete(void *p, size_t size)
    {
        free(p);
    }

};

То, что я делаю, использовать совокупную инициализацию, но только определение инициализаторов для участников я забочусь о, например:

STARTUPINFO si = {
    sizeof si,      /*cb*/
    0,              /*lpReserved*/
    0,              /*lpDesktop*/
    "my window"     /*lpTitle*/
};

остающиеся участники будут инициализированы к нулям соответствующего типа (как в сообщении Drealmer). Здесь, Вы доверяете Microsoft для не бесплатного повреждения совместимости путем добавления новых элементов структуры в середине (разумное предположение). Это решение кажется мне оптимальный - один оператор, никакие классы, никакой memset, никакие предположения о внутреннем представлении нулевых или нулевых указателей с плавающей точкой.

я думаю, что взломы, включающие наследование, являются ужасным стилем. Общедоступное наследование значит ISA для большинства читателей. Обратите внимание также, что Вы наследовались классу, который не разработан, чтобы быть основой. Как нет никакого виртуального деструктора, клиенты, которые удаляют экземпляр производного класса через указатель на основу, вызовут неопределенное поведение.

Это - немного кода, но это является допускающим повторное использование; включайте его однажды, и это должно работать на любой POD. Можно передать экземпляр этого класса к любой функции, ожидая MY_STRUCT или использовать функцию GetPointer для передачи его в функцию, которая изменит структуру.

template <typename STR>
class CStructWrapper
{
private:
    STR MyStruct;

public:
    CStructWrapper() { STR temp = {}; MyStruct = temp;}
    CStructWrapper(const STR &myStruct) : MyStruct(myStruct) {}

    operator STR &() { return MyStruct; }
    operator const STR &() const { return MyStruct; }

    STR *GetPointer() { return &MyStruct; }
};

CStructWrapper<MY_STRUCT> myStruct;
CStructWrapper<ANOTHER_STRUCT> anotherStruct;

Таким образом, Вы не должны волноваться о том, являются ли ПУСТЫЕ УКАЗАТЕЛИ всем 0 или представлениями с плавающей точкой. Пока STR является простым составным типом, вещи будут работать. Когда STR не будет простым составным типом, Вы получите ошибку времени компиляции, таким образом, Вы не должны будете волноваться о случайном неправильном использовании этого. Кроме того, если тип содержит что-то более сложное, пока это имеет конструктора по умолчанию, Вы в порядке:

struct MY_STRUCT2
{
    int n1;
    std::string s1;
};

CStructWrapper<MY_STRUCT2> myStruct2; // n1 is set to 0, s1 is set to "";

На оборотной стороне, это медленнее, так как Вы делаете дополнительную временную копию, и компилятор присвоит каждого участника 0 индивидуально вместо одного memset.

Мое мнение нет. Я не уверен, что это получает также.

, Поскольку Ваше определение CMyStruct изменяется, и Вы добавляете/удаляете участников, это может привести к ошибкам. Легко.

Создают конструктора для CMyStruct, который берет MyStruct, имеет параметр.

CMyStruct::CMyStruct(MyStruct &)

Или что-то вроде, которое искало. Можно затем инициализировать общедоступного или частного члена 'MyStruct'.

Точное расположение класса или структуры не гарантируется в C++, который является, почему Вы не должны делать предположения о размере его с внешней стороны (который означает, не являетесь ли Вы компилятором).

, Вероятно, это работает, пока Вы не находите компилятор, на котором это не делает, или Вы бросаете некоторых vtable в соединение.

Примеры имеют "неуказанное поведение".

Для не-POD, порядок, согласно которому компилятор размечает объект (все классы оснований и участники) является неуказанным (ISO C++ 10/3). Рассмотрите следующее:

struct A {
  int i;
};

class B : public A {       // 'B' is not a POD
public:
  B ();

private:
  int j;
};

Это может быть размечено как:

[ int i ][ int j ]

Или как:

[ int j ][ int i ]

Поэтому использование memset непосредственно на адресе 'этого' является в значительной степени неуказанным поведением. Один из ответов выше, на первый взгляд надеется быть более безопасным:

 memset(static_cast<MY_STRUCT*>(this), 0, sizeof(MY_STRUCT));

я полагаю, однако, что строго говоря это также приводит к неуказанному поведению. Я не могу найти нормативный текст, однако в примечании в 10/5 говорится: "Подобъект базового класса может иметь расположение (3.7) отличающийся от расположения большей части производного объекта того же типа".

В результате я компилятор мог выполнить оптимизацию пространства с различными участниками:

struct A {
  char c1;
};

struct B {
  char c2;
  char c3;
  char c4;
  int i;
};

class C : public A, public B
{
public:
  C () 
  :  c1 (10);
  {
    memset(static_cast<B*>(this), 0, sizeof(B));      
  }
};

Может быть размечен как:

[ char c1 ] [ char c2, char c3, char c4, int i ]

В системе на 32 бита, из-за выравнивания и т.д. для 'B', sizeof (B), скорее всего, составит 8 байтов. Однако sizeof (C) может также быть '8' байты, если компилятор упаковывает элементы данных. Поэтому вызов к memset мог бы перезаписать значение, данное 'c1'.

Если у Вас уже есть конструктор, почему не просто инициализируют его там с n1=0; n2=0; - это - конечно, больше нормальный путь.

Редактирование: На самом деле, поскольку paercebal показал, ctor инициализация еще лучше.

Это - идеальный пример портирования идиомы C к C++ (и почему это не могло бы всегда работать...)

проблема, которую Вы будете иметь с использованием memset, то, что в C++, структура и класс являются точно тем же самым за исключением того, что по умолчанию, структура имеет общедоступную видимость, и класс имеет частную видимость.

Таким образом, что, если позже, некоторый хорошо имеющий в виду программист изменяет MY_STRUCT как так:

struct MY_STRUCT
{
    int n1;
    int n2;

   // Provide a default implementation...
   virtual int add() {return n1 + n2;}  
};

Путем добавления, что единственная функция, memset мог бы теперь вызвать опустошение. Существует детальное обсуждение в comp.lang.c +

Вы можете просто инициализировать значение-значение базы, и все ее члены будут обнулены. Это гарантировано

struct MY_STRUCT
{
    int n1;
    int n2;
};

class CMyStruct : public MY_STRUCT
{
public:
    CMyStruct():MY_STRUCT() { }
};

Чтобы это работало, в базовом классе не должно быть конструктора, объявленного пользователем, как в вашем примере.

Никакого противного memset для этого. Это' s не гарантирует, что memset работает в вашем коде, даже если он должен работать на практике.

Если MY_STRUCT ваш код, и вы довольны использованием компилятора C ++, вы можете поместить туда конструктор, не оборачивая его классом:

struct MY_STRUCT
{
  int n1;
  int n2;
  MY_STRUCT(): n1(0), n2(0) {}
};

Я не уверен в эффективности, но я ненавижу трюки, когда вы не доказали, что эффективность нужна.

Я полагаю, что структура предоставлена ​​вам и не может быть изменена. Если вы можете изменить структуру, то очевидным решением будет добавление конструктора.

Не создавайте чрезмерно свой код с помощью оболочек C ++, когда все, что вам нужно, - это простой макрос для инициализации вашей структуры.

#include <stdio.h>

#define MY_STRUCT(x) MY_STRUCT x = {0}

struct MY_STRUCT
{
    int n1;
    int n2;
};

int main(int argc, char *argv[])
{
    MY_STRUCT(s);

    printf("n1(%d),n2(%d)\n", s.n1, s.n2);

    return 0;
}