Recursive macros in C

Hinzugefügt: 2026-05-09

[00:00:04]Sup, guys.

[00:00:05]Welcome to today's show.

[00:00:07]So is it possible to count function arguments in C?

[00:00:12]Let's say I have a function which I'm calling like this.

[00:00:16]So something like this.

[00:00:21]So this I want to return three.

[00:00:24]And if we have a fourth argument, I want it to return four.

[00:00:30]How do we do that?

[00:00:32]We cannot do it with functions, that's for sure.

[00:00:35]But perhaps we can do it with macros if we manage to make them recursive.

[00:00:44]Let's try.

[00:00:47]How do we do this?

[00:00:49]Let's say let's make it easy.

[00:00:52]Let's say that we have a null terminating function for now.

[00:01:00]So if and if x is zero.

[00:01:09]In that case, we want to return the arguments.

[00:01:14]No, let's say we want to return the number of arguments.

[00:01:21]Otherwise we want to return count with the current number of arguments plus one and and then the rest of the arguments.

[00:01:44]So we peel off one argument at a time because we return Xs.

[00:01:50]We do not return the first argument and the rest.

[00:01:56]So this could actually work.

[00:02:02]So how would we initialize such a thing?

[00:02:09]We could do something like if we call this count, underscore first, and then we define the regular count, which only takes or is so Xs.

[00:02:28]And this will return, underscore, count and start the recursion by.

[00:02:36]So by providing the zero as the number starting number and and then providing the arguments like this.

[00:02:51]So let's just to have something let's say we have let's create an integer data type.

[00:03:00]So we say we have an unsigned SHA, which we call a, and here in a let's say number of we have an in a number of args, which is equal to count.

[00:03:24]And then we have this a, B, C, like this.

[00:03:36]Let's see what the preprocessor makes out of this.

[00:03:44]First does it to even compile.

[00:03:57]Oh, what happens if we run?

[00:04:03]Let's see if we run c p, That's the C preprocessor.

[00:04:31]So it translates this.

[00:04:36]So if a is zero, we return zero.

[00:04:44]Otherwise, count of zero plus one, B and C.

[00:04:49]So this part seemed to work, but the preprocessor doesn't really like the we define this recursive word if we were to first define this as something else.

[00:05:17]So let's say a, B, C, and the return zero or something.

[00:05:27]This should compile like thing because this should be the same right?

[00:05:36]We get a warning, that's really fine, but does it compile count as the same problem?

[00:05:57]No implicit declaration of Why is an implicit declaration?

[00:06:17]Because we we do define here.

[00:06:39]Oh, so maybe because of the wrong number of arguments.

[00:06:45]It's not. Hmm.

[00:06:57]This, however, does make sense.

[00:06:59]It's not the constant. So let's move this into here instead.

[00:07:20]Stuck in here.

[00:07:24]What if we were to do something like this?

[00:07:28]So we define it with two argument works.

[00:07:34]Let's define it like this.

[00:07:54]And maybe just like this one.

[00:08:15]But this.

[00:08:15]It's an implicit declaration.

[00:08:18]It does exist.

[00:08:21]And the preprocessor itself makes the right thing out of it.

[00:08:41]Is it possible to bypass the error or the.

[00:08:53]Could we simply remove the this shit?

[00:09:35]Hmm. What if we had a similar function but with a different name?

[00:10:00]So let's say we have and we had the same problem here instead.

[00:10:50]So we find this with this and this with this.

[00:12:22]It's weird where it complains on the underscore count, but no, it's on the double underscore, I guess, because this is the first location.

[00:13:23]How can we go around this?

[00:13:32]Could we bounce like create a function?

[00:13:52]Maybe.

[00:14:01]So how would that look?

[00:14:05]Something like in a town, the total.

[00:15:00]All right.

[00:15:01]Let's see what happens.

[00:15:16]My actual count requires three arguments, but only one gives them.

[00:15:36]That's right.

[00:15:37]This needs to be above.

[00:15:46]Okay.

[00:15:47]It compiles.

[00:15:48]That's interesting.

[00:16:02]See, with Preprocessor says, like, if this is going to call this function, let's see if A is here, returns here was if B is the real returns zero plus one and zero plus one plus one.

[00:17:53]So the idea were that we would probably need to have as many levels as there might be arguments.

[00:18:26]Let's just try to add one more level.

[00:18:36]So this would be code with three, right here calling the one with two to call and one with one.

[00:18:51]Where am I going?

[00:18:52]The wrong direction here.

[00:18:59]The second calls underscore count, underscore, count.

[00:19:13]Those two double underscore the below underscore goes to three and three would go to four.

[00:19:56]Let's make the the fun so this expected expression isn't is basically what we did before we're just given a rule the country first this underscore count with this 12341234.

[00:22:07]One, two, three, four.

[00:22:10]Let's call this one f count instead the function count.

[00:22:35]What does the c c preprocessor say?

[00:22:44]Ethereal. Zero other words.

[00:22:47]If this zero, then zero plus one and the C zero we have zero plus one +12, then zero plus one plus one.

[00:23:34]Then use this and this other words you have if count of zero plus one plus one plus oh.

[00:23:47]Is the argument because there's no argument left.

[00:24:12]What if we were to just do this?

[00:24:17]What would happen then?

[00:24:25]Still the same problem.

[00:24:54]So how do we deal with the.

[00:25:09]So this is why I wanted to create my own C person pass through because it's so very limited.

[00:25:18]The abilities in the Xs is nothing at this point.

[00:25:36]Maybe we need to do this.

[00:25:41]Yeah, we do.

[00:25:43]I forgot about the node terminator, so that's really true.

[00:26:06]We need to add every.

[00:26:14]But that won't really help.

[00:26:15]Will be let's.

[00:26:27]Yeah.

[00:26:36]Must actually work.

[00:26:38]Let's try to print something like this too.

[00:27:16]Pretty nice.

[00:27:17]And what if we were to add the C here?

[00:27:27]Then it goes to zero.

[00:27:29]But if we have just one, then it goes to one.

[00:27:39]Okay, so we need to have one more of these underscore macros than we need.

[00:27:53]And then we have arguments.

[00:27:56]So if we were to continue this, we would after a while have something that actually works.

[00:28:16]It doesn't make the cleanest looking code, but but the general idea works.

[00:28:36]And why do we need something like this?

[00:28:39]Well, if we are able to do this kind of recursion, there's should be possible to to create a like a generic console.log log function similar to JavaScript.

[00:28:59]So we don't have to deal with print death and format strings and kinds of variables.

[00:29:06]We could just say print and whatever.

[00:29:11]So maybe that will be the next step.

[00:29:15]What do you think?

[00:29:16]Could we do something other with this?

[00:29:20]And besides, do you have a cleaner solution to this?

[00:29:24]Please let me know.

[00:29:26]And I really hope you like this episode.

[00:29:30]Don't forget to like and subscribe and thank you for watching.

[00:29:34]And for today.