Использование макроса __ LINE __ - C

Привет!

Я реализую функцию в C, что позволил получать реестр более подробный, чем случается в программе, что-то похожее с debug, но стараясь обобщать вещи для программиста.

Я встретился с документацией Предпроцессора CPP (GNU/Linux) и там они показывали различные макросы и постоянные величины, которые могут быть использованными в нашей программе так что также могут быть использованными функции и использовать там этих макросы.

Благодаря этому я реализовал следующую программу:

#include <stdio.h>
#include <stdlib.h>

/* Dump para variables */
#define dump(variable) {   \
    printf("La variable '%s' ocupa %d bytes\n", #variable, sizeof(variable)); \
}

/* Dump para funciones */
#define dumpf(){ \
    printf("Se llama a funcion %s()\n", __FUNCTION__); \
}

void funcion(int argumento){
    dumpf();
    printf("%d\n", argumento + argumento);
}

void sumar(int a, int b){
    dumpf();
    printf("%d + %d = %d\n", a, b, (a+b));
}

int main(int argc, char *argv[]){

    /* Variables */
    int variableINT   = 45;
    char variableCHAR = 'A';
    char *variablePTR = "Hola Mundo";

    /* Debug de Variables*/
    dump(variableINT);
    dump(variableCHAR);
    dump(variablePTR);

    /* Debug de Funcion*/
    funcion(10);
    sumar(5, 5);

   return EXIT_SUCCESS;
}

Эта программа позволяет, что мы узнали вес в байт переменной благодаря функции dump (), также позволяет знать, что мы называем функцию посредством функции dumpf ().

До этой точки, результат программы в консоли:

Переменная 'variableINT' занимает 4 байт

Переменная 'variableCHAR' занимает 1 байт

Переменная 'variablePTR' занимает 4 байт

Называется в функцию функция ()

20

Он называет в функцию суммировать ()

5 + 5 = 10

После этого, чтобы делать немного более читабельный и более легкий для того, чтобы наш "debug" быть понятен, я захотел добавить что-то, что показывало линию, где оно делалось названный к функции, следовательно сделал следующее изменение в функции dumpf ():

/* Dump para funciones */
#define dumpf(){ \
    printf("Se llama a funcion %s() en la linea %d\n", __FUNCTION__, __LINE__); \
}

Я добавил макрос LINE, который теоретически показывает нам линию, где работает преподавание.

Но результат, который бросает программу:

Называет в функцию функцию () в линии 15

20

Он называет в функцию складывать () в линии 20

А именно покажи мне линию, где я называю оригинально в функцию внутри каждой из функций функцию () и суммировать (), он не показывает линию, где она была названа действительно функцией, которая в действительности линий 37 и 38.

Как было бы возможно получать линию, в которой он был сделан названный к функции? Какой-то недостаток существует в макросе LINE, включившись в функцию? Так как предполагается, что Предпроцессор заменяет эту стоимость перед тем, как делать компиляцию.

Я благодарен заранее за Вашу помощь.

4
задан 14.02.2017, 02:30
0 ответов

То, что ты ищешь, так это макрос, который говорил бы тебе, что функции было названо с линии X и это не будет функционировать, если ты называешь макрос с самой функции... Подумай, что сообщение производится во времени компиляции..., составитель в этом моменте не знает, откуда ты позвонишь в функцию.

Чтобы получать то, к чему ты стремишься, ты был бы должен называть макрос перед тем, как звонить в функцию (или приспосабливать макрос для того, чтобы та же самая была способна звонить в функцию)... в любом случае, не что-то слишком практическое:

// "hack" para convertir el nombre de un parametro en una cadena
#define ___TOSTRING(x) #x
#define TOSTRING(x) ___TOSTRING(x)

#define dumpf(FUNC) \
    printf("Se llama a funcion %s() en la linea %d\n", TOSTRING(FUNC), __LINE__); \
    FUNC

int main(int argc, char *argv[]){

    /* Variables */
    int variableINT   = 45;
    char variableCHAR = 'A';
    char *variablePTR = "Hola Mundo";

    /* Debug de Variables*/
    dump(variableINT);
    dump(variableCHAR);
    dump(variablePTR);

    /* Debug de Funcion*/
    dumpf(funcion)(10);
    dumpf(sumar)(5, 5);

   return EXIT_SUCCESS;
}

И результат был бы:

La variable 'variableINT' ocupa 4 bytes
La variable 'variableCHAR' ocupa 1 bytes
La variable 'variablePTR' ocupa 4 bytes
Se llama a funcion funcion() en la linea 37
20
Se llama a funcion sumar() en la linea 38
5 + 5 = 10

Если тебе интересно иметь разметки выполнения, может быть, ты был бы должен ставить учиться использовать отладчик кода... в программах, таких маленьких как тот, кто не имеет чувства помещать образцы слишком много система разметок.

5
ответ дан 03.12.2019, 17:30

Как было бы возможно получать линию, в которой он был сделан названный к функции?

Каким бы то ни было образом. Информация, которую ты ищешь, - stack наметьте какового он определен во время выполнения в то время как макросы как __LINE__ и __FUNCTION__ они состоят tokens в том, что пред-процессор переводит в буквальных, непосредственно перед составив.

А именно, макрос __LINE__ написанная в линии 100 будет переведен буквальным 100 перед тем, как составлять. Единственный способ был бы перемещая в каждую функцию параметр показывая точку вызова:

void funcion(int argumento, int linea){
    printf("%d\nllamada en %d\n", argumento + argumento, linea);
}

void sumar(int a, int b, int linea){
    printf("%d + %d = %d\nllamada en %d\n", a, b, (a+b), linea);
}

/*09*/int main(void)
/*10*/{
/*11*/    funcion(1, __LINE__);
/*12*/    sumar(3, 2, __LINE__);
/*13*/    return 0;
/*14*/}

Вызов в funcion(1, __LINE__) она будет переведена пред-процессором в funcion(1, 11) в то время как sumar(3, 2, __LINE__) он будет переведен в sumar(3, 2, 12).

Возможно ты думал, что это тебе достаточно, и ты можешь использовать назначенные по умолчанию параметры..., но оно не функционировало бы:

/*01*/void funcion(int argumento, int linea = __LINE__){
/*02*/    printf("%d\nllamada en %d\n", argumento + argumento, linea);
/*03*/}
/*04*/
/*05*/void sumar(int a, int b, int linea = __LINE__){
/*06*/    printf("%d + %d = %d\nllamada en %d\n", a, b, (a+b), linea);
/*07*/}

int main(void)
{
    funcion(1);
    sumar(3, 2);
    return 0;
}

Предыдущий код, пройдя по пред-процессору, он остался бы как:

/*01*/void funcion(int argumento, int linea = 1){
/*02*/    printf("%d\nllamada en %d\n", argumento + argumento, linea);
/*03*/}
/*04*/
/*05*/void sumar(int a, int b, int linea = 5){
/*06*/    printf("%d + %d = %d\nllamada en %d\n", a, b, (a+b), linea);
/*07*/}

Так что вывод программы был бы:

1
llamada en 1
3 + 2 = 5
llamada en 5

Что уже ты знаешь, что он фальшивый, так как функции назвали в линиях 11 и 12.

Заключение.

Консультируй документацию твоего составителя, чтобы видеть, можешь ли ты соглашаться на stack наметьте в течение выполнения программы.

1
ответ дан 03.12.2019, 17:30