programación - visual basic excel 2013

¿Cómo generar una nueva línea en una macro cpp?

Question

¿Cómo escribo una macro cpp que se expande para incluir nuevas líneas?

Answer 1

Los compiladores C y C ++ ignoran los espacios en blanco sin comillas (excepto por el problema de la plantilla>), por lo que hacer que una macro emita nuevas líneas en realidad no tiene sentido. Puede hacer que un macro abarque varias líneas al terminar cada línea de la macro con una barra diagonal inversa, pero esto no genera nuevas líneas.

Answer 2

No es posible. Solo sería relevante si estuvieras mirando los archivos de la lista o la salida del preprocesador.

Una técnica común al escribir macros para que sean más fáciles de leer es usar el carácter / para continuar la macro en la siguiente línea.

Yo (creo que) he visto compiladores que incluyen nuevas líneas en las macros expandidas en la salida de la lista, para su beneficio. Esto solo nos sirve a los humanos pobres que leen las macros expandidas para tratar de comprender lo que realmente le pedimos al compilador que hiciera. no hace ninguna diferencia para el compilador.

Los lenguajes de C & C ++ tratan todos los espacios en blanco fuera de las cadenas de la misma manera. Solo como un separador

Answer 3

No estoy muy seguro de lo que estás preguntando aquí. ¿Quieres un macro en múltiples líneas?

#define NEWLINE_MACRO(x) line1 /
line2 /
line3

Además, si desea incluir un literal en su macro:

#define NEWLINE_MACRO(x) ##x

lo que pones en x se pondrá en lugar de ## x, entonces:

NEWLINE_MACRO( line1 ) // is replaced with line1

Esto puede ser útil para crear funciones globales personalizadas y solo necesita cambiar parte del nombre de la función.

También:

#define NEWLINE_MACRO(x) #x // stringify x

Pondrá citas alrededor de x

Answer 4

Use la / al final de la línea. He visto muchos C macos en los que usan un do ... mientras (0)

#define foo() do /
{
  //code goes here /
  /
  /
}while(0);

Además, recuerde utilizar las fases principales en muchas instancias.

Ejemplo:

#define foo(x) a+b
//should be
#define foo(x) (a+b)

Answer 5

El compilador de C conoce el espacio en blanco, pero no distingue entre espacios, pestañas o líneas nuevas.

Si te refieres a cómo tengo una nueva línea dentro de una cadena en una macro, entonces:

#define SOME_STRING "Some string/n with a new line."

trabajará.

Answer 6

Use / , como ese:

#define my_multiline_macro(a, b, c) /
if (a) { /
    b += c; /
}

Answer 7

Estoy trabajando en un gran proyecto que implica muchas funciones macro de preprocesador para sintetizar cualquier código que no pueda ser reemplazado por plantillas. Créanme, estoy familiarizado con todo tipo de trucos de plantilla, pero mientras no haya un lenguaje de metaprogramación seguro y estandarizado que pueda crear código directamente, tendremos que seguir con el viejo preprocesador y sus macros engorrosos para resolver algunos problemas que requeriría escribir diez veces más código sin. Algunas de las macros abarcan muchas líneas y son muy difíciles de leer en el código preprocesado. Por lo tanto, pensé en una solución a ese problema y lo que se me ocurrió es lo siguiente:

Digamos que tenemos una macro C / C ++ que abarca múltiples líneas, por ejemplo, en un archivo llamado MyMacro.hpp

// Content of MyMacro.hpp

#include "MultilineMacroDebugging.hpp"

#define PRINT_VARIABLE(S) /
__NL__  std::cout << #S << ": " << S << std::endl; /
__NL__  /* more lines if necessary */ /
__NL__  /* even more lines */

En cada archivo donde definí dicha macro, incluyo otro archivo MultilineMacroDebugging.hpp que contiene lo siguiente:

// Content of MultilineMacroDebugging.hpp

#ifndef HAVE_MULTILINE_DEBUGGING
#define __NL__
#endif

Esto define una macro vacía __NL__ , que hace que las definiciones __NL__ desaparezcan durante el preprocesamiento. La macro se puede usar en alguna parte, por ejemplo, en un archivo llamado MyImplementation.cpp .

// Content of MyImplementation.cpp

// Uncomment the following line to enable macro debugging
//#define HAVE_MULTILINE_DEBUGGING

#include "MyMacro.hpp"

int a = 10;
PRINT_VARIABLE(a)

Si necesito depurar la macro PRINT_VARIABLE , simplemente descomente la línea que define la macro HAVE_MULTILINE_DEBUGGING en MyImplementation.cpp . El código resultante, por supuesto, no se compila, ya que la macro __NL__ resulta indefinida, lo que hace que permanezca en el código compilado, pero puede, sin embargo, preprocesarse.

El paso crucial ahora es reemplazar la cadena __NL__ en la salida del preprocesador por nuevas líneas usando su editor de texto favorito y, voila, termina con una representación legible del resultado de la macro reemplazada después del preprocesamiento que se asemeja exactamente a lo que vería el compilador. a excepción de las líneas nuevas introducidas artificialmente.