How can Python, a language that supports Object Oriented Programming, be implemented in C, which is not an Object Oriented Programming language?

Question

To my understanding, C does not have the concept of objects, then how can Python be implemented in C to support something that C can not? How is the concept of "Object" modeled in C? What is internally used?

Edit : Reading through the comments, I am interested in this specific implementation of Python which "uses" C to make the whole thing work. More specifically how is a python "object" represented in C.

As an example in comments, something like a Banking System can use "Classes" to model it, like so how can C model the Python concept of Object.

Answer 1

Higher level abstractions are routinely implemented with lower level building blocks.

For example, C higher level language constructs are themselves implemented with lower level assembler instructions. And the same applies to object orientation, which is often implemented with non-object oriented techniques.

Objects are made of data and behavior. C does not know objects, but it knows data structures and functions:

• To implement "methods" that would operate on data structures in C, to emulate basic object orientation, you can define C functions that take a pointer to the data structure as one of their argument (usually the first). Of course, doing this manually is not practical, and you can easily forget to call the method to initialise an object that was just allocated. But if you have a compiler, it's easy to make sure that this is done systematically. It's also easy for to transform a call such as a.do_something(b,c,d) into do_something(a,b,c,d).

• To implement methods that change depending on some condition, in C you can use function pointers. A function pointers can point to any function that have a given "signature" (i.e. return type and argument with types). This allows to implement some dynamic dispatching such as what is needed for polymorphism. It is then easy to enrich the inital data structure with some function pointers. Or to enrich it with a pointer to another datastructure that holds the name and function pointer of each relevant method corresponding to a guiven class

• If the language implemented allows functions/methods with variable number of arguments, you could opt for reduced number of arguments in C, such as the pointer to the data structure holding the object's data, a pointer to a list of arguments.

• If the language implemented allows for dynamic typing, all method arguments discussed so far would simply be a data structure that holds information about the type of the data, and the data itself, i.e. in C a pair of pointers to different structures).

• If you need to allow inheritance and multiple inheritance, it gets tricky, but you would work either on generating a composed data structures, or organise the data structure with some pointers that point to a parent object, along with the code to properly access the data following the chain.

• And for every other language construct, there is probably already a solution. Because ultimately, the thing will run on a microprocessor with very low-level elementary machine instructions.

Answer 2

TL;DR: different level of abstractions. There is really no such thing as an object, there are just 1’s and 0’s and interpretations of them.

The CPU doesn’t know about objects, so the same question would apply for it: how can you you have a compiler for a language with objects, when the CPU it targets doesn’t know about objects? And the answer is the same, objects are an abstracts where data and functions are bound together by a convention/standard and it is this convention/standard that really defines an object. While the standard isn’t defined in C, C is able to create an implementation of this standard.

This is in fact how C++ and Obj-C were first created. C was a good choice for doing this, because of its cross platform support and hardware support. This made it possible to write a C++ compiler that not only ran on many different platforms, it also compiled for the many different platforms.

To go back to the CPU example, the CPU doesn’t even know about strings, it just knows about bytes, typically having a register size of 1, 2, 4 or 8 bytes. How can it deal with strings? Easy, it doesn’t. The compiler has a convention/standard that it imposes on itself. Strings in C are really just null terminated chunks of memory. In Python, a string is a variable sized structure that takes 49 to 80 bytes in memory PLUS the chunks of memory that is the “characters”. But all of this is totally irrelevant to the CPU. A python programs “strings” aren’t going to be C strings even though the program is compiled to C, because when the code is compiled to C it isn’t going to use the C conventions for strings when dealing with python strings, it will use python conventions, executed in C.