Mensajes

Pon:

Código (cpp) [Seleccionar] Expandir

RegCreateKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",&hkey);

Nótese que en el path, retiré el primer "\\", con el cual falla.

Si vas a hacer un protocoo con varios comandos, entonces ponle un identificador del comando al principio:

Código [Seleccionar] Expandir

CMD -> 1 byte
if CMD = A {
    protocolo A 
}else if CMD = B {
    protocolo B
}

Ej. Este mismo protocolo, pero del lado del Arduino: https://github.com/ivancea/Arduino-Interpreter/blob/master/arduino_program.c

[00015678<datos>]

Si lo que quieres es responderle al Arduino tras recibir el número, pues nada, es eso. Tras enviar el número, el Arduino tendrá que esperar la respuesta. NO sé qué es exactamente lo que no sabes hacer (solo es enviar, esperar y recibir, al fin y al cabo)


Otra opción es recibir el número en una cantidad de bytes fija. Es decir, 2 posibilidades:
1) Enviar el número "en binario". Un int son 4 bytes, así que solo tendrías que leer 4 bytes. (Si nunca trabajaste con datos binarios, puedes saltarte esta opción temporalmente)
2) Enviar, por ejemplo, 8 caracteres fijos, y rellenarcon ceros: 00015678<datos>.

También puedes poner un delimitador:
15678;<datos>
Pones el punto y coma (o cualquier caracter no-numérico) después, y ya sabes cuando dejar de leer el número.

Si el protocolo es:

Código [Seleccionar] Expandir

N -> 5 bytes
{ N BYTES }

Pues primero lees los primeros 5 bytes, los conviertes a un entero, y se lo pones de longitud al array.
Luego, lees esos N bytes (o lo que sea).

No inicializas c*

Y bueno, static es útil pero, intenta no abusar xD

Código (cpp) [Seleccionar] Expandir

static char s[i];
Eso te va a generar un array de longitud i la primera vez que se llame a la función, y tendrá ese tamaño siempre.
Deberías suar memoria dinámica qsi quieres que sea dinámico.

Edito: Diría que la declaración static de ese array es ilegal, así que evítala. Punteros, memoria dinámica es la solución.

Código (cpp) [Seleccionar] Expandir

int* getArray(unsigned int size){
    static int* array = nullptr;
    if(array != nullptr){
        delee[] array;
    }
   
    array = new int[size];
    return array;
}

Por ejemplo, ahí tienes una función que te da un array de X tamaño de cuya memoria no tienes que preocuparte (es un ejemplo trivial y poco útil, pero es un ejemplo).

Otra posibilidad es almacenar un estado. Por ejemplo, un generador de números aleatorios:

Código (cpp) [Seleccionar] Expandir

#include <ctime>
#include <iostream>

using namespace std;

int random(int newSeed = -1){
static int seed = 4974654;
if(newSeed != -1)
seed = newSeed;
else
seed = (seed + 784513)%530789;
return seed;
}

int main(){
random(time(0));
for(int i=0; i<10; i++)
cout << random()%10 << endl;
}

[decltype]

Nunca se me dio este caso (no es nada recomendable hacer una clase anónima y definir luego sus miembros fuera, no debería haber razones apra ello).

En cualquier caso, te propongo una posibilidad:

Código (cpp) [Seleccionar] Expandir

void decltype(o)::foo(){
    // ...
}

decltype, de C++11, obtiene en tiempo de compilación el tipo de lo que le metas dentro.

Por ejemplo:

Código (cpp) [Seleccionar] Expandir

int n = 5;
decltype(n) j = 7;
Ambos son int.

Puedes usarlo, admeás, en templates o macros.

[thread_local]

La idea del static es que el dato se mantenga de llamada a llamada pero solo sea accesible para esa función. Si sabes que debes usar ese dato fuera de la función hazlo global.

Lo que comenta el fafafa01 también es posible, y se puede utilizar para evitar que el programador que utilice la función se preocupe por la memoria.
Por ejemplo, una variable static es una posible forma de hacer la función localtime de la librería time.h/ctime: http://www.cplusplus.com/reference/ctime/localtime/

A parte de static, otro especificador remarcable es thread_local, que funciona como static, solo que cada nuevo thread tendrá su propia variable.

http://en.cppreference.com/w/cpp/language/operator_precedence

Esos casos no dan mucho pié a error. Un post-incremento no se ejecuta hasta el final de la instrucción/línea (de forma genérica).

Ese (i++) que pusiste, no es el operator(). "i()" es el operator (), que es como una llamada a función. Rodear unas operaciones con () no es un operador. Simplemente haces que ese bloque se ejecute completo (cuando se necesite) antes de continuar evaluando.

Para probar estas cosas de forma práctica, siempre puedes crear una clase para ello:

Código (cpp) [Seleccionar] Expandir

#include <iostream>

using namespace std;

class Test{
public:
Test operator+(const Test& test){
cout << " +";
}

Test operator++(){
cout << " ++_";
}

Test operator++(int){
cout << " _++";
}

Test operator[](const Test& test){
cout << " []";
}

Test operator=(const Test& test){
cout << " =";
}

operator int(){
cout << " int";
}
};

int main(){
cout << "Order:";

Test a,b;

a[++a] = b++;
cout << endl;

(int)(a+b);
cout << endl;

(int)a+b;
cout << endl;
}

Es difícil responder a esto.

Dices que es un juego, así que intuyo que tendrás algún tipo de bucle principal. Podría ser ahí donde lo hagas (llamar a una función que lo actualice si han pasado 5 segundos, por ejemplo)