Count source file lines using macros?

There is the __LINE__ preprocessor macro which gives you an integer for the line is appeared on. You could take its value on some line, and then some later line, and compare.

static const int BEFORE = __LINE__; foo(); bar(); baz(); quux(); static const int AFTER = __LINE__; static const int COUNT = AFTER - BEFORE - 1; // 4 

If you want to count the occurrences of something rather than source lines, __COUNTER__ might be a non-standard option, supported by some compilers such as GCC and MSVC.

#define MAGIC2_2(c) #define MAGIC2(c) MAGIC2_2(c) static const int BEFORE = __COUNTER__; void foo(); MAGIC2(__COUNTER__); void bar( int multiple, float lines); MAGIC2(__COUNTER__); void baz(); MAGIC2(__COUNTER__); void quux(); MAGIC2(__COUNTER__); static const int AFTER = __COUNTER__; static const int COUNT = AFTER - BEFORE - 1; // 4 

I took the initial value of __COUNTER__ because it might have been used previously in the source file, or some included header.

In C rather than C++ there are limitations on constant variables, so an enum might be used instead.

enum MyEnum { FOO = COUNT // C: error: enumerator value for ‘FOO’ is not an integer constant }; 

Replacing the const with enum:

enum {BEFORE = __LINE__}; foo(); bar(); baz(); quux(); enum { COUNT = __LINE__ - BEFORE - 1}; enum MyEnum { FOO = COUNT // OK }; 

I know that the OP's request is to use macros, but I would like to add another way of doing this that does not involve using macros.

C++20 introduces the source_location class that represents certain information about the source code, such as file names, line numbers, and function names. We can use that pretty easily in this case.

#include <iostream> #include <source_location> static constexpr auto line_number_start = std::source_location::current().line(); void foo(); void bar(); static constexpr auto line_number_end = std::source_location::current().line(); int main() { std::cout << line_number_end - line_number_start - 1 << std::endl; // 2 return 0; } 

And live example here.

For completeness: If you're willing to add MAGIC2 after every line, you can use __COUNTER__:

#define MAGIC2 static_assert(__COUNTER__ + 1, ""); /* some */ MAGIC2 void source(); MAGIC2 void lines(); MAGIC2 constexpr int numberOfLines = __COUNTER__; int main() { return numberOfLines; } 

https://godbolt.org/z/i8fDLx (returns 3)

You can make it reusable by storing the start and end values of __COUNTER__.

Overall this is really cumbersome though. You also won't be able to count lines that contain preprocessor directives or that end with // comments. I'd use __LINE__ instead, see the other answer.

Based on your comment, if you want to specify a (compile-time) array size in C or C++, you can do

int array[]; //incomplete type enum{ LINE0 = __LINE__ }; //enum constants are integer constant expressions /*lines to be counted; may use array (though not sizeof(array)) */ /*...*/ int array[ __LINE__ - LINE0 ]; //complete the definition of int array[] 

If you need sizeof(array) in the intervening lines, you can replace it with a static variable reference (unless it absolutely needs to be an integer constant expression) and an optimizing compiler should treat it just the same (eliminate the need for the static variable to be placed in memory)

int array[]; static int count; enum{ LINE0 = __LINE__ }; //enum constants are integer constant expressions //... possibly use count here enum { LINEDIFF = __LINE__ - LINE0 }; int array[ LINEDIFF ]; /*complete the definition of int array[]*/ static int count = LINEDIFF; //fill the count in later 

A __COUNTER__-based solution (if that extension is available) as opposed to a __LINE__-based one will work the same.

constexprs in C++ should work as well as enum, but enum will work in plain C as well (my solution above is a plain C solution).