qué hace cout <" "[a==N]; do?

cout<<"\n"[a==N];

No tengo ni idea de lo que hace la opción [] en cout

En Tabla de precedencia del operador C++ , operator [] se une más fuerte que operator <<, por lo que su código es equivalente a:

cout << ("\n"[a==N]);  // or cout.operator <<("\n"[a==N]);

O, en otras palabras, operator [] no hace nada directamente con cout. Se utiliza solo para la indexación de cadena literal "\n"

Por ejemplo for(int i = 0; i < 3; ++i) std::cout << "abcdef"[i] << std::endl; imprimirá caracteres a, b y c en líneas consecutivas en la pantalla.

Porque literales de cadena in C++ are always terminated with null character('\0', L'\0', char16_t(), etc), una cadena literal {[10] } es un const char[2] que contiene los caracteres '\n' y '\0'

En el diseño de memoria esto se ve así:

+--------+--------+
|  '\n'  |  '\0'  |
+--------+--------+
0        1          <-- Offset
false    true       <-- Result of condition (a == n)
a != n   a == n     <-- Case

Así que si a == N es true (promovido a 1), la expresión "\n"[a == N] resulta en '\0' y '\n' si el resultado es false.

Es funcionalmente similar (no igual) a:

char anonymous[] = "\n";
int index;
if (a == N) index = 1;
else index = 0;
cout << anonymous[index];

El valor de "\n"[a==N] es '\n' o '\0'

El tipo de "\n"[a==N] es const char

Si la intención es imprimir nada (que puede ser diferente de imprimir '\0' dependiendo de la plataforma y el propósito), prefiera la siguiente línea de código:

if(a != N) cout << '\n';

Incluso si su intención es escribir '\0' o '\n' en la secuencia, prefiera un código legible, por ejemplo:

cout << (a == N ? '\0' : '\n');

Probablemente sea una forma extraña de escribir{[14]]}

if ( a != N ) {
    cout<<"\n";
}

El operador [] selecciona un elemento de una matriz. La cadena "\n" es en realidad una matriz de dos caracteres: una nueva línea '\n' y un terminador de cadena '\0'. Así que cout<<"\n"[a==N] imprimirá un carácter '\n' o un carácter '\0'.

El problema es que no se le permite enviar un carácter '\0' a una secuencia de E/S en modo texto. El autor de ese código podría haber notado que nada parecía suceder, por lo que asumimos que cout<<'\0' es una forma segura de no hacer nada.

En C y C++, esa es una suposición muy pobre debido a la noción de comportamiento indefinido. Si el programa hace algo que no está cubierto por la especificación del estándar o la plataforma en particular, cualquier cosa puede suceder. Un resultado bastante probable en este caso es que la secuencia dejará de funcionar por completo - no aparecerá más salida a cout en absoluto.

En resumen, el efecto es,

"Imprimir una nueva línea si a no es igual a N. De lo contrario, no lo sé. Choque o algo así."

{y la moraleja es, no escribas las cosas tan crípticamente.

No es una opción de cout sino un índice de matriz de "\n"

El array index [a==N] se evalúa como [0] o [1], e indexa el array de caracteres representado por "\n" que contiene una nueva línea y un carácter nul.

Sin embargo, pasar nul al iostream tendrá resultados indefinidos, y sería mejor pasar una cadena:

cout << &("\n"[a==N]) ;

Sin embargo, el código en cualquier caso no es particularmente aconsejable y no sirve para otro propósito particular que ofuscar; no lo considere como un ejemplo de buenas prácticas. Lo siguiente es preferible en la mayoría de los casos:

cout << (a != N ? "\n" : "") ;

O simplemente:

if( a != N ) cout << `\n` ;

Cada una de las siguientes líneas generará exactamente la misma salida:

cout << "\n"[a==N];     // Never do this.
cout << (a==N)["\n"];   // Or this.
cout << *((a==N)+"\n"); // Or this.
cout << *("\n"+(a==N)); // Or this.

Como las otras respuestas han especificado, esto no tiene nada que ver con std::cout. En cambio es una consecuencia de

• Cómo se implementa el operador de suscripción primitivo (no sobrecargado) en C y C++.
  En ambos lenguajes, si array es una matriz de primitivas estilo C, array[42] es azúcar sintáctica para *(array+42). Peor aún, no hay diferencia entre array+42 y 42+array. Esto conduce a ofuscación interesante: Use 42[array] en lugar de array[42] si su objetivo es ofuscar completamente su código. No hace falta decir que escribir 42[array] es una idea terrible si su objetivo es escribir código comprensible y mantenible.

• Cómo se transforman los booleanos en enteros.
  Dada una expresión de la forma a[b], a o b debe ser una expresión puntero y la otra; la otra debe ser una expresión entera. Dada la expresión "\n"[a==N], el "\n" representa el parte puntero de esa expresión y el a==N representa la parte entera de la expresión. Aquí, a==N es una expresión booleana que evalúa a false o true. Las reglas de promoción de enteros especifican que false se convierte en 0 y true se convierte en 1 en la promoción a un entero.

• Cómo los literales de cadena se degradan en punteros.
  Cuando se necesita un puntero, los arrays en C y C++ se degradan fácilmente en un puntero que apunta al primer elemento del matriz.

• Cómo se implementan los literales de cadena.
  Cada literal de cadena de estilo C se añade con el carácter nulo '\0'. Esto significa que la representación interna de su "\n" es el array {'\n', '\0'}.

Dado lo anterior, supongamos que a==N evalúa a false. En este caso, el comportamiento está bien definido en todos los sistemas: obtendrá una nueva línea. Si, por otro lado, a==N evalúa a true, el comportamiento es altamente dependiente del sistema. Basado en comentarios a las respuestas a la pregunta, a Windows no le gustará eso. En sistemas tipo Unix donde std::cout es canalizado a la ventana terminal, el comportamiento es bastante benigno. No pasa nada.

Solo porque puedas escribir código así no significa que debas hacerlo. Nunca escribas código así.