Saltos de línea en formato Clang

Entonces, después de jugar con el código de formato clang y hacer algunos parches, aquí están mis dos centavos:

• El formato Clang se basa en,

  • analizar el AST usando libclang , que básicamente elimina todos los espacios en blanco
  • dividir la secuencia del token en "líneas abiertas" que son como líneas de código "lógicas"
  • Aplicar reglas/información de configuración para dividir a veces "líneas no envueltas" en unidades más pequeñas
  • Escúpelo todo de nuevo con nuevos espacios en blanco / sangría

  No es fácil hacer que respete el espacio en blanco original, que se descarta cuando se analiza el código por primera vez.

• Puede controlar dónde coloca los saltos de línea, más fácilmente,

  • establecer el límite de columna
  • utilizando las opciones de "parámetros del paquete de contenedores"
  • establecer penalizaciones para varios tipos de interrupciones:interrupción después del tipo de retorno de una función, interrupción antes del primer parámetro de llamada, interrupción de una cadena literal, interrupción de un comentario...
  • colocar comentarios al final de una línea (el formato clang no puede eliminar el comentario y, por lo tanto, debe dividir la línea)
  • usar las directivas off/on de formato clang

Aquí hay algo que podrías probar:

std::vector<std::string> get_vec()
{
   return std::vector<std::string> {   //
      "this is a test",                //
      "some of the lines are longer",  //
      "than other, but I would like",  //
      "to keep them on separate lines" //
   };
}

La ventaja de esto sobre // clang-format off es que, si luego cambia el ancho de la pestaña o alguna otra opción, esas líneas de código seguirán teniendo esos cambios de formato, por lo que no necesita ingresar manualmente al // clang-format off regiones para arreglarlo. Sin embargo, sigue siendo un truco, YMMV.

En última instancia, clang-format se trata en gran medida de imponer un formato uniforme sobre una base de código completa, asegurándose de que todos los literales de cadena tengan el mismo estilo en todas partes de su programa. Si desea tener un control de nivel micro sobre las decisiones de salto de línea, eso no está realmente en el espíritu de la herramienta, y tendrá que hacer cosas como deshabilitarla.

Esto a veces puede ser frustrante, especialmente. cuando quiere hacer cosas con matrices y tener columnas alineadas o algo así, por ejemplo, aquí hay un código natural de lua C api:

static luaL_Reg const methods[] = {
    {"matches",               &dispatch::intf_match_unit},
    {"to_recall",             &dispatch::intf_put_recall_unit},
    {"to_map",                &dispatch::intf_put_unit},
    {"erase",                 &dispatch::intf_erase_unit},
    {"clone",                 intf_copy_unit},
    {"extract",               &dispatch::intf_extract_unit},
    {"advance",               intf_advance_unit},
};

Cuando el formato clang pasa por encima de eso, generalmente no va a alinear la columna derecha, va a colocarla en un número fijo de espacios después de las comas y no hay mucho que puedas hacer al respecto.

O, si tiene una matriz de 4 x 4 para usar con OpenGL:

      constexpr float shadow_skew_hardcoded[16] =
        { 1.0f, 0.0f, 0.0f, 0.0f,
          0.5f, 0.5f, 0.0f, 0.0f,
          0.0f, 0.0f, 1.0f, 0.0f,
          0.0f, 0.0f, 0.0f, 1.0f };

Si permite que el formato clang se ejecute sobre cosas como esta, simplemente las destrozará, y afaik no hay una manera fácil de formatearlas bien, por lo que solo tiene que recurrir al truco de "muchos comentarios triviales" o usar desactiva el formato clang cuando tienes algo como esto. Estas son solo limitaciones intrínsecas de la herramienta. Si no está feliz de tener que hacer cosas así, entonces probablemente no sea la herramienta para usted.

No estoy seguro de que clang-format haga exactamente lo que quiere, pero es posible decirle a clang-format que deje partes del código en paz. Lo uso exactamente para el tipo de escenario del que está hablando, bloques de código donde un formato muy particular hace que sea más fácil de leer.

std::vector<std::string> get_vec()
{
   // clang-format off
   return std::vector<std::string> {
      "this is a test",
      "some of the lines are longer",
      "than other, but I would like",
      "to keep them on separate lines"
   };
   // clang-format on
}

Consulte:http://clang.llvm.org/docs/ClangFormatStyleOptions.html#disabling-formatting-on-a-piece-of-code

Agregue una coma después de la última cadena. Esto le dice a clang-format que lo formatee verticalmente. Ej:https://godbolt.org/z/bZxr__ Haga clic derecho> formato de texto

#include <string>
#include <vector>

std::vector<std::string> get_vec() {
  return std::vector<std::string>{
      "this is a test",
      "some of the lines are longer",
      "than other, but I would like",
      "to keep them on separate lines", // comma here after last element
  };
}

int main() { auto vec = get_vec(); }