Хочется изменять переменные

VV - не переменная, а может быть определена как угодно. Например, как *(SomeAddress + SomeOffset)

Ну а так, в случае С++, лучше смотреть в сторону шаблонов. Они, кстати, чистые, но можно запилить числа Черча:

http://nonchalantlytyped.net/blog/2010/04/24/church-numerals-in-c/ (первый попавшийся пример)

Ну и, да, есть #undef и https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/Push_002fPop-Macro-Pragmas.html

хорошо не переменная, а как угодно.

я определил
#define V 100
теперь хочу
INC(V) //v=101
INC(V) //v=102

как подобное сделать?

push_macro и undef не поможет, потому как V нужно определить через V

Зачем? Может, inline-функции подойдут?

http://stackoverflow.com/a/16474500/2935339

Макросы работают немного не так. Ты можешь работать с ними лишь один раз, на препроцессинге. Потому в макрос засунуть макрос не выйдет.

Воспринимай их лучше как константы, но не языковые. =)

Единственное, что ты можешь сделать, так это #define INC(x) x+1, но саму x он не изменит.

Я к чему это, лучше придумать другой способ, чем костылять. Вон выше придумали как сделать, но это ужас.

Макросы работают немного не так. Ты можешь работать с ними лишь один раз, на препроцессинге. Потому в макрос засунуть макрос не выйдет.

Я знаю. Мне нужен данный функционал. может такое можно сделать через m4 или boost. Не обязательно стандартный препроцессор С++

http://stackoverflow.com/a/16474500/2935339

добавить число к макросу можно. только как полученный результат присвоить макросу, это проблема

Тут есть пример использования BOOST_PP_COUNTER.

Спасибо. Но хотелось бы не только инкремент, а еще остаток от деления

Я знаю. Мне нужен данный функционал.

функционал

Граммар-наци негодуют.

man constexpr

Так это же значение, с ним можно делать всё что угодно, BOOST_PP_COUNTER%BASE и т.д. Или я не так понял? Если речь о «присвоении», то разницы по значениям ведь не будет. Либо можно написать аналогичные макросы для остатка, что, если BASE маленькое и фиксированное, довольно легко.

#define BOOST_PP_COUNTER 0
#define MACRO(V) func(V, BOOST_PP_COUNTER);\
здесь я хочу увеличить BOOST_PP_COUNTER на V.
как это сделать?

...
MACRO(0);
MACRO(2);
...

Внутри другого макроса не выйдет, так как результат разворачивания макросов не сможет заинклюдить файлы, которые реализуют инкремент.

Можно попробовать использовать этот вариант на C++ и эти макросы:

#define r9(S) S; r8(S)
#define r8(S) S; r7(S)
#define r7(S) S; r6(S)
#define r6(S) S; r5(S)
#define r5(S) S; r4(S)
#define r4(S) S; r3(S)
#define r3(S) S; r2(S)
#define r2(S) S; r1(S)
#define r1(S) S;

#define REPEAT(V, S) REPEAT_(V, S)
#define REPEAT_(V, S) REPEAT__(V, S)
#define REPEAT__(V, S) r##V(S)

REPEAT(4,counter_inc(my_cnt))

См. __COUNTER__

Но он умеет только инкремент. Если нужно что-то более развернутое, то начиная с C++11 есть всякие constexpr-ы, а с C++14 они даже вроде могут что-то существенное считать. Остальное - либо макросная магия типа того, что выше, либо всё ручками делать.

Что не так?

это еще что

Тебе надо менять в коде определённую в макросах переменную?

Заведи обычную переменную, используй её и меняй. А инициализируй значением макроса.

Что не так?

функционал != функциональность

ok, чем же они отличаются?

чиста игра ума

#define inc(vv) #define tmp vv\ #undef vv \ #define vv (tmp+1)\ #undef tmp

не работает очевидно, но вот как то так

вообщет обычные препроцессор (тем более современых стандартов) в плюссах очень ограниченый.

если тебе нужно на этапе компиляции иметь константы с вот таким вот поведением кури шаблоны (они как развитие препроцессора , доказано тьюрингполны_)

т.е шаблонами можно(вряд ли нужно) злоупотреть так что полученно будет желаемое тобой поведение

нечто тобой одинаково именнуемое в код попадёт как различное непосредственно значение по мере твоих «inc»

ok, чем же они отличаются?

ппц. Погугли. Функционал бывает только в математике.

Уже по заголовку можно понять, что ты поступаешь неправильно.

Граммар-наци получают в зубы тяжёлым и увесистым профессиональным жаргоном и укладываются отдохнуть.

И математики тоже

Функционал - это отображение чего-то (например L^2) на ℂ

ТСу уже показывали бреинфак на C препроцессоре?

А какую задачу ТС решает?

constexpr-ы. В редакции C++14 они стали достаточно много уметь, в том числе локальные переменные, циклы всякие.

{REPEAT(4,{-1,-2})}

{REPEAT(4,{REPEAT(3,-3)})}

слабо?

В смысле? Второе и так работает, а для первого из-за запятой надо S в аргументах на ... заменить, а в других местах на __VA_ARGS__, ну и запятую вместо точки с запятой использовать между результатами.

template <int Val, int Arg>
struct strange_compile_time_math
{
  enum res_val { r_plus = Val + Arg, r_mod = Val % Arg};
};
// используем
if( 8 == strange_compile_time_math<5,3>::r_plus)
  exit(1);

Можно сделать обобщенным если намешать свойства типов, и явно указать тип значений enum, с 11-го стандарта так можно.

в этом коде нет большого смысла для данной задачи.
strange_compile_time_math<0>::val --> 0
strange_compile_time_math<N>::val --> N
strange_compile_time_math<M>::val --> M+N
strange_compile_time_math<Z>::val --> M+N+Z

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

Данную задачу можно решить с помощью m4, но тогда придется каждый cpp файл пропускать через него. не хочется

Хочется изменять переменные на этапе компиляции.

быдлокод

Зачем такие извращения? ТС, может ты про отладчики не знаешь, что тебе переменные на этапе компиляции менять захотелось?

#define N1 4
#define N2 3
#define N3 2

#define EX0
#define EX1(a)       a
#define EX2(a,b)     a,b
#define EX3(a,b,c)   a,b,c
#define EX4(a,b,c,d) a,b,c,d

#define REP1(j,a) EX##j a
#define REP2(j,a) EX##j a,EX##j a
#define REP3(j,a) EX##j a,EX##j a,EX##j a
#define REP4(j,a) EX##j a,EX##j a,EX##j a,EX##j a

#define REP(n,j,v)      REP_(n,j,v)
#define REP_(n,j,v) { REP##n (j,v) }

int m[N1] = REP(N1,0,-1);
int m[N1] = REP(N1,1,(-1));
int m[N1][N2] = REP(N1,N2,(REP(N2,0,-2)));
int m[N1][N2] = REP(N1,N2,({-3,-4,-5}));
int m2[N1][N2][1]= REP(N1,N2,(REP(N2,0,{-4})));
int m2[N1][N2][1]= REP(N1,N2,(REP(N2,1,({-4}))));
int m2[N1][N2][N3]= REP(N1,N2,(REP(N2,N3,({-4,-5}))));
int m2[N1][N2][N3]= REP(N1,N2,(REP(N2,N3,(REP(N3,0,-9)))));

последние 2 не работают, хотя вроде должны

Так вроде работает.

#define N1 4
#define N2 3
#define N3 2

#define r9(...) __VA_ARGS__, r8(__VA_ARGS__)
#define r8(...) __VA_ARGS__, r7(__VA_ARGS__)
#define r7(...) __VA_ARGS__, r6(__VA_ARGS__)
#define r6(...) __VA_ARGS__, r5(__VA_ARGS__)
#define r5(...) __VA_ARGS__, r4(__VA_ARGS__)
#define r4(...) __VA_ARGS__, r3(__VA_ARGS__)
#define r3(...) __VA_ARGS__, r2(__VA_ARGS__)
#define r2(...) __VA_ARGS__, r1(__VA_ARGS__)
#define r1(...) __VA_ARGS__

#define REPEAT(V, ...) REPEAT_(V, __VA_ARGS__)
#define REPEAT_(V, ...) REPEAT__(V, __VA_ARGS__)
#define REPEAT__(V, ...) r##V(__VA_ARGS__)

#define REP(n,j,...)      REP_(n,j, __VA_ARGS__)
#define REP_(n,j,...) { REPEAT(n, __VA_ARGS__) }

int m1[N1] = REP(N1,0,-1);
int m2[N1] = REP(N1,1,-1);
int m3[N1][N2] = REP(N1,N2,REP(N2,0,-2));
int m4[N1][N2] = REP(N1,N2,{-3,-4,-5});
int m5[N1][N2][1]= REP(N1,N2,REP(N2,0,{-4}));
int m6[N1][N2][1]= REP(N1,N2,REP(N2,1,{-4}));
int m7[N1][N2][N3]= REP(N1,N2,REP(N2,N3,{-4,-5}));
int m8[N1][N2][N3]= REP(N1,N2,REP(N2,N3,REP(N3,0,-9)));

Проблема с двумя последними в наличии запятой, препроцессор выполняет очень ограниченный разбор, на вложенность большинства скобок ему побоку. Те же function-like macros в коде в стандарте описаны как «имя за которой непосредственно следует (», с запятыми примерно то же самое, т.е. он делает strchr(sourceline, ','), а что там на пути попадётся, ему неважно. Больше на простую обработку текста похоже, только препроцессор ещё строковые литералы знает.