C/C++ - é possibile programmare a oggetti in c ?

così, domanda secca; forse mi riterrete stupido per avervela posta !

Nessuna domanda è stupida. La risposta è no. Se vuoi programmare a oggetti utilizza il C++

La domanda è molto astuta invece... la risposta, lasciatemi fare il bastian contrario, è SI!

Il linguaggio non supporta nativamente gli oggetti, ma puoi usare delle convenzioni per questo...

ti faccio un esempio:

// Definizione di fake-class in C
// MiaClasse.h

#ifndef _MIACLASSE_H
#define _MIACLASSE_H

typedef struct _MiaClasse
{
  int m_id;
  char * m_Name;
  short m_Param;
} MiaClasse;

// Funzioni membro: attenzione in C non esiste il puntatore implicito all'istanza corrente (il "this" per intenderci), quindi ci occuperemo di passarlo manualmente

void MiaClasse_Init(MiaClasse *pThis, int id, char* name, short param); // Il costruttore
void MiaClasse_Destroy(MiaClasse *pThis); // Il distruttore
const char * MiaClasse_GetName();
void MiaClasse_SetName(); // Metodi di incapsulamento

#endif

poi definiamo l'implementazione

// MiaClasse.c

#include "MiaClasse.h"

void MiaClasse_Init(MiaClasse *pThis, int id, char* name, short param)
{
  if (pThis == NULL)
     return;

  pThis->m_id = id;
  pThis->m_Name = name;
  pThis->m_Param = param;
}

// .... ecc....

Quando poi, in un altro punto del codice, dovrai usare questa classe, farai così:

// main.c

#include "MiaClasse.h"

int funzioneQualsiasi()
{
  MiaClasse prova; // Variabile locale

  // Chiamo il costruttore manualmente, uso & per avere l'indirizzo sullo stack
  MiaClasse_Init(&prova, 1, "ciao", 0); // valori a caso

  // uso la classe
  printf("chupa : %s\n", MiaClasse_GetName(&prova));
  
  // Chiamo il distruttore
  MiaClasse_Destroy(&prova);

}

La stessa cosa vale per le allocazioni dinamiche (quelle con il "new" del C++, per intenderci).

// main.c

#include "MiaClasse.h"

int funzioneQualsiasi()
{
  MiaClasse *prova = malloc(sizeof(*prova)); // Allocazione dinamica

  // Chiamo il costruttore manualmente, "prova" è già un puntatore, non serve &
  MiaClasse_Init(prova, 1, "ciao", 0); // valori a caso

  // uso la classe
  printf("chupa : %s\n", MiaClasse_GetName(prova));
  
  // Chiamo il distruttore
  MiaClasse_Destroy(prova);

  // Libero la memoria
  free(prova);


}

Usando queste convenzioni in modo accurato, puoi programmare ad oggetti in C, anche se con diverse limitazioni, ma la struttura "semantica" rimane quella dell'OOP.

Si può implementare anche il polimorfismo se vuoi, se ti interessa posso dartene un esempio...
Ciao e buono studio

Si in questo modo si potrebbe aggirare il problema ma si hanno delle limitazioni che in un linguaggio che li supporta nativamente come, ad esempio, il VB.NET non ci sono.

Ovvio... ma in questo modo puoi scrivere anche programmi da 200 mila linee di codice in C su piattaforme estremamente lente (cosa che ho fatto in passato sul Nintendo DS), senza rinunciare alla comodità della struttura OOP propria di linguaggi più evoluti (e meno efficienti in termini di istruzioni macchina).

saprei come implementare il polimorfismo, ma ciò è come darsi la zappa sui piedi, come ha detto TheKaneB programmare a oggetti in c è utile soprattutto per aumentare le prestazione, ma il polimorfismo le riduce drasticamente !

ps : grazie per le risposte !

potresti eventualmente usare objective-c.
E' nativo come linguaggio ed è 100% compatibile col C standard.
Ed è intrinsicamente oop.