Aloque a memória do objeto estaticamente; inicializar dinamicamente?

Eu tenho um objeto cujo construtor é passado um parâmetro. Se eu souber o valor do parâmetro em tempo de compilação, posso construir o objeto estaticamente:

static FOOOBJ foo(3);

(Entendo que não é realmente feito estaticamente, ou seja, pelo compilador, mas na verdade é feito durante a instalação).

Mas se eu não souber o valor do parâmetro no tempo de compilação, ainda gostaria de pré-alocar espaço para o objeto, mas construí-lo nesse espaço no tempo de execução. Isso pode ser feito sem um .initialize()método separado ?

O uso de um initialize()método para uma classe é contrário ao princípio de um construtor de classe, ou seja, uma vez que uma instância de classe tenha sido construída , ela deve estar " pronta para uso ".

Conforme sugerido pela resposta de Ignacio, a sintaxe de posicionamento do C ++ é muito melhor para o seu propósito.

No entanto, nas bibliotecas do Arduino, a sintaxe de posicionamento não é suportada "pronta para uso", portanto você deve implementá-lo; não tema, isso é bem direto:

void* operator new(size_t size, void* ptr)
{
    return ptr;
}

A sintaxe da veiculação pode ser uma besta complexa em C ++, mas para seu objetivo específico, seu uso pode ser bastante simples:

static char buffer[sizeof FOOOBJ];
static FOOOBJ* foo;

void setup() {
    ...
    foo = new (buffer) FOOOBJ(3);
    ...
}

A diferença com seu código atual é que fooagora é um ponteiro; portanto, qualquer chamada de método será usada em ->vez de ..

Se você quiser continuar usando foocomo instância e não como ponteiro, poderá fazê-lo (mas não o aconselho como explicado mais adiante) usando uma referência :

static char buffer[sizeof FOOOBJ];
static FOOOBJ& foo = *((FOOOBJ*) buffer);

void setup() {
    ...
    new (buffer) FOOOBJ(3);
    ...
}

O problema com esse código é que você não pode saber se foojá foi construído com uma FOOOBJinstância real ou não; usando um ponteiro, você sempre pode verificar se é 0ou não.

Usando a sintaxe do canal, você deve estar ciente de que não pode deletea fooinstância acima. Se você deseja destruir foo(ou seja, garantir que seu destruidor seja chamado), é necessário chamar explicitamente o destruidor:

foo->~FOOOBJ();

Você pode usar a sintaxe do canal para especificar uma alocação existente na qual instanciar a classe.

FOOOBJ foo(0);

 ...

  FOOOBJ *f = new (foo) FOOOBJ(3);