Question regarding library functions/macros

Hi everyone, I am currently learning C using KNKing C prrogramming a modern approach.

I am currently learning about the functions in the stdio.h library. There are some parts where it talks about how some functions are usually implemented as a macro while others are implemented only as a function?

E.g. this part about input functions fgetc, getc, getchar and ungetc.

"The relationship between getc and fgetc is similar to that between putc and fputc. getc is usually implemented as a macro (as well as a function) while fgetc is implemented only as a function. getchar is normally a macro as well:

#define getchar() getc(stdin) "

I have some questions: What does it mean by functions are implemented as macros while sometimes implemented as functions?

also how can getchar, which is a function in the stdlib library, be define as a macro? Thank you all.

There are a kind of macros called function-style macros that allow for macros that look like functions. Being a macro, you get the same simplistic text replacement of macros, hence avoiding function call overhead, and being function-style, you can pass arguments to the macro, except that those arguments aren't evaluated but rather the text replacement mechanism applies.

I see. So some "commands" in the library can be both macros AND functions (and if used they are macros, unless i add "()" to them to force the machine to compile it as a function), while some "commands" are only functions? Thank you sir.

Quote:

---

So some "commands" in the library can be both macros AND functions

---

I didn't say that. They can be macros or functions, but not both at the same time.

Quote:

---

(and if used they are macros, unless i add "()" to them to force the machine to compile it as a function),

---

I didn't say that at all either. I talked about function-style macros, not about macros that become functions when you add parentheses.

Function-style macros are macros, not functions. The idea is that the standard allows some functions to be implemented as macros instead. If the implementation chooses this option, then they are macros, not functions.

There is a long history here....

Back in the old days optimizing compilers (as we know them now) didn't exist. The compiler was very much a "Garbage In, Garbage Out" thing. Memory was much smaller than today, and CPU cycles much more more expensive. I still remember using Lattice C, which required 96KB or RAM and two floppy disks...

Design decisions were made. One of those was that for really trivial functions they would be implemented as macros. The reason for this was that the time taken to setup and call the function and return would be a significant proportion of the execution time, and that overweighed other concerns like code size.

One easy to talk about example could be "int isdigit(int c)":

Code:

---

int isdigit(int c) {
  return (c >= '0' && c <= '9');
}

---

To save resources, and speed up the program it could be implemented as a macro:

Code:

---

#define isdigit(c) (c >= '0' && c <= '9')

---

This could be the logical choice at the time, but if implemented this way it introduces bugs. For example

Code:

---

  i += isdigit(getchar());

---

would become:

Code:

---

  i += (getchar() >= '0' && getchar() <= '9');

---

And this calls getchar() twice.

Quote:

---

Originally Posted by laserlight

They can be macros or functions, but not both at the same time.

---

They can be both at the same time.
You can ensure you call the function by putting parens around the function name in the call.

Code:

---

#include <stdio.h>
 
void abc(int x) {
    printf("func: %d\n", x);
}
 
#define abc(x) printf("%d\n", x)
 
int main() {
    abc(123);  // calls the macro
    (abc)(123); // calls the function
    return 0;
}

---

I see. Thank you all for the reply! :)