i don`t know i just never learned anything but C and asm. ps. i use doom emacs for its package manager over VIm or its flavors.
Transprogrammer
A space for trans people who code
Matrix Space:
- #transprog:socki.moe
Rules:
- Don't be a meanie
- no *ism
- consider the feelings of somebody who might read what you say
- Don't shitpost
- Keep it wholesome
- Must be trans / programming related
C programmer here. I can't code in Rust and although I do have some interest in learning it, C is still the best one to me. Probably not the best way to do it, but I'd do something like this (based on the code in your ss):
typedef struct Player{
float pos_x;
float pos_y;
float rotation;
} Player;
Player player_new(){
Player player;
player.pos_x = 0.0;
player.pos_y = 0.0;
player.rotation = 0.0;
return player;
}
void player_move(Player *player, float x, float y){
player->pos_x += x;
player->pos_y += y;
return;
}
void player_rotate(Player *player, float by){
player->rotation += by;
return;
}
int main(int argc, char *argv[]){
Player player1 = player_new();
player_move(&player1, 10.0, 10.0);
player_rotate(&player1, 180.0);
return 0;
}
I would probably move the struct Player
and the functions player_new
, player_move
and player_rotate
to another file (like player.c
or sth), I'd create its respective header file with the definitions of each thing and with that I basically created a simple interface to create and handle players without needing OOP. English is not my native language, so I'm not really sure about what's the name of the programming paradigm used in C (which definitely is not OOP), but in my native language we call it "programación estructurada", which in English would be something like "structured programming".
Tbh I code in both non-OOP and OOP languages (most of the time C, JS and Python) and to me both paradigms are just fine. You can pretty much do anything in either, but each of them might work better for you on different situations and depending on your needs. I also use Vim btw.
I'm sorry but this is effectively just OOP but worse.
You're still defining methods of the player class here but the referenced object/struct is explicit rather than implicit. Contrary to languages that properly support OOP though, they're entirely separated from each other and entirely separate from the data type they effectively represent methods of as far as the language is concerned. They only share an implicit "namespace" using the player_
function name prefix convention which is up for humans to interpret and continue.
There's still quite a few software written in C that does exactly as I did though. Look at OpenSSL's EVP library. I'm not sure about what you mean by "OOP but worse", wouldn't everything be worse than OOP since C isn't an OOP language? Anyways. As I said, what I did is way more common than it seems at least in C, so I get your point but still I can't seem to be able to see what's inherently wrong with it. I would appreciate if you shared any better ideas you might have, though!