An “interface” in C (unlike in C++/Java/C#) is not a built‑in language feature, but a design pattern you create using function pointers and structs.

Core idea in plain words

In C, an interface is usually:

  • A struct that holds a set of function pointers (and sometimes metadata).
  • A convention: “Any module that wants to be considered a Foo must provide functions matching these signatures and fill this struct correctly.”

So it’s a way to define a contract of behavior, even though C itself doesn’t have interface syntax like Java or C#.

Mini example: “Shape” interface in C

You might define a “shape interface” as:

c

typedef struct Shape Shape;  // forward declaration

typedef struct {
    double (*area)(Shape *self);
    void   (*draw)(Shape *self);
} ShapeVTable;

struct Shape {
    const ShapeVTable *vtable;
    /* common data or a void* to implementation data */
};

Each concrete type (e.g., Circle, Rectangle) provides implementations:

c

double circle_area(Shape *self);
void   circle_draw(Shape *self);

static const ShapeVTable circle_vtable = {
    .area = circle_area,
    .draw = circle_draw
};

Any code that takes a Shape * and calls shape->vtable->area(shape) is working through the interface , without knowing whether it’s a circle or rectangle.

Why people call this an “interface” in C

Developers borrow the word “interface” from object‑oriented programming, where an interface is a set of method signatures that types must implement. In C, you simulate that idea by:

  • Grouping related behavior into a struct of function pointers.
  • Making all “implementations” fill that struct with the right functions.
  • Writing code against the function‑pointer table, not concrete types.

This gives you:

  • Polymorphism (different types, same API).
  • Loose coupling (caller doesn’t depend on concrete implementation).
  • Testability (you can plug in mock implementations easily).

Quick scoop style summary

  • C has no nativeinterface keyword.
  • You build interfaces yourself using struct + function pointers conventions.
  • The interface is really a contract of function signatures that modules agree to implement.
  • This is widely used in C libraries, drivers, and plugin systems to get OO‑like behavior.

TL;DR: In C, an “interface” is just a pattern: a struct of function pointers that defines what operations something must support, and any implementation fills that struct with its own functions.

Meta note (for your SEO / blog post needs):
Your focus keyword “what is an interface in c” naturally fits if you explain that C doesn’t have native interfaces, but you can implement an interface‑like contract via structs of function pointers and call that an interface pattern.