Programming

If your goal is to rewrite your python code in C with minimal hassle, start thinking of objects as structs with functions attached to them. If you detach the functions from the structs, instead having them take structs as an argument, then you can obtain something which is C-like but likely very unoptimised.

Personally, I think I would steer you towards Rust or C++ instead - both can run just as quickly, but have more OOP features and modern features which may make moving easier. Learning C is still a very good thing to do, but I'm not sure this project would be the best project to do that with.

There are a many approaches to implementing OOP in C. Since C doesn’t give you any language constructs to implement this out of the box, it’s up to you to do it in a consistent and understandable manner. Since there is no definite way to do it, let me just give you an example of how I would translate a Python file, and you can decide how you implement it from there:

--------------
class Parent:
    def __init__(self, param1: str, param2: int):
        self.__param1 = param1
        self.__param2 = param2
    def __private_method(self):
        print("private method")
    def public_method(self):
        print("public method")
    @staticmethod
    def static_method():
        print("static method")
    @property
    def param1(self):
        return self.__param1

class Child(Parent):
    def __init__(self):
        super().__init__("param1", 2)
--------------

I would split the C code for this into header and source files:

(header.h)

--------------
#pragma once

/// Parent Class ///
typedef struct Parent_obj {
    char* param1
    unsigned int param1_len
    int param2
} Parent_obj_t;
void Parent_init(Parent_obj_t* self, char* param1, unsigned int param1_len, int param2);
void Parent_public_method(Parent_obj_t* self);
void Parent_static_method();
void Parent_param1(Parent_obj_t* self, char* out, unsigned int max_len); // property method with upper bound string length
void Parent_del(Parent_obj_t* self); // destruct object (similar to __del__() in python)

/// Child Class ///
typedef struct Child_obj {
    Parent_hidden_state_t* super
    char* param
    unsigned int param_len
} Child_obj_t
void Child_init(Child_obj_t* self, Parent_obj_t* super);
void Child_del(Child_obj_t* self);
--------------

(source.c)

--------------
#include "header.h"

/// Parent Class ///
// private methods
void Parent_private_method(Parent_obj){...}
// public methods
void Parent_init(Parent_obj_t* self, char* param1, unsigned int param1_len, int param2){...}
void Parent_public_method(Parent_obj_t* self){...}
void Parent_static_method(){...}
void Parent_param1(Parent_obj_t* self, char* out, unsigned int max_len){...}
void Parent_del(Parent_obj_t* self){...}

/// Child Class ///
// public methods
void Child_init(Child_obj_t* self, Parent_obj_t* super){...}
void Child_del(Child_obj_t* self){...}
--------------

Modules and namespaces can be modeled using folders and prefixing your structs and functions.

Is this community going to be for noon questions and people who won't read tutorials?

Just trying to decided if I should block it like the noob only programming reddits.