la forma más rápida de negar un número

Use algo que sea legible, como

a *= -1;

O

a = -a;

Deje el resto al optimizador.

Las otras respuestas han indicado correctamente que la legibilidad importa más:

• Debe olvidarse de la velocidad y elegir el idioma que encuentre más legible.
• Casi todos los compiladores (con optimizaciones habilitadas) entienden que a = -a y a *= -1 son exactamente iguales y emitirán cualquier asm que decidan que será más eficiente en la CPU de destino, independientemente de cómo lo escriba. (por ejemplo, Godbolt compiler explorer para x86 gcc/MSVC/clang, y ARM gcc.)
  • Pero aunque MSVS 2012 (solo en modo de depuración) usa una instrucción para cada uno, toman 1 ciclo para = -a y 3 para *= -1 en CPU Intel recientes, usando una instrucción real imul.
• Cualquier intento de hacerlo más rápido hará que sea mucho menos legible y fácilmente podría hacerlo más lento.
• Si necesita optimizar, debe comenzar por analizar el código generado y el rendimiento.

Hay sin embargo una ventaja práctica a la *= -1 modismo: solo tienes que escribir el lado izquierdo una vez, solo se evalúa una vez - ¡y el lector solo tiene que leerlo una vez! Esto es relevante cuando el LHS es largo, complejo o costoso o puede tener efectos secundarios:

(valid ? a : b)[prime_after(i++)] *= -1;
*look_up (input) *= -1;  // Where look_up may have side-effects
parity[state][(unsigned int)getc(stdin)] *= -1;
variable_with_a_long_explanatory_name *= -1;

Y una vez que uno ha adoptado un idioma, uno tiende a quedarse con él en otras situaciones.

Suponiendo que el procesador es al menos algo competente y tiene sizeof(int) == sizeof(Cpu_register), entonces un "make this number negative" será una sola instrucción (generalmente llamada neg) [bueno, puede necesitar el valor de carga y almacenamiento también, pero si está utilizando la variable para cualquier otra cosa, puede permanecer después de la carga, y solo se almacenará más tarde...]

Multiplicarse por -1 es probablemente más lento que a = -a;, pero la mayoría de los compiladores competentes deberían ser capaces de hacer ambos equivalentes.

Así que, solo escribe el código claramente, y el resto debe cuidarse solo. Negar un número no es una operación difícil en la mayoría de los procesadores. Si está usando algún processsor inusual, entonces mire la salida del compilador, y vea lo que hace.

También 0-n

Gcc emite la instrucción " neg " para los cuatro casos: - n, 0-n, n * -1, y ~n + 1

Solución usando lenguaje de alto nivel

Preguntas como estas son populares en entrevistas y en el mundo de la programación competitiva .

Aterricé aquí investigando más solución para la negación de un número sin usar el operador - o+.

Para esto :

1. complementar un número usando ~ operador
2. Luego agregue 1 al número obtenido en el paso 1 usando la lógica de media sumadora:

> int addNumbers(int x, int y)
>       {
>                    if(y==0)  return x; // carry is 0 
>                    return addNumbers(x^y,(x&y)<<1);
>         }

Aquí x^y realiza la adición de bits y las manijas x e y llevan la operación

Puedes probar

int a = 10;
a= ~a+1;

Pero no debería preocuparse por eso, porque compilador lo hace de la mejor manera.