Hur nära kan man komma åt hårdvaran via C vs C++?

[Al_Bundy]

Jag ser fler och fler skriver "man kan visst programmera objektorienterat med C!!!". Men varför sägs det allmänt att man inte kan göra det?

Jag är helt övertygad att man kan programmera objektorienterat via C, utan dessa "C++ klasser". Men jag har aldrig sett något exempel

Här är ett exempel på hur man skulle kunna tänka lite "objektorienterad" i C:

Kod: Markera allt

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef void (*work)(void*);

typedef struct _person {

    char name[20];
    int age;
    struct _person* owner;
    work dowork;
} Person;

typedef struct
{
    Person person;
    char title[20];
    
} Manager;


typedef struct
{
    Person person;
    char title[20];
    char workdescription[50];
    
} Employee;



void manager_work(Manager*manager)
{
    printf("Manager %s is now busy doing whatever a %s is doing\n", manager->person.name, manager->title);
}

void employee_work(Employee*employee)
{
    printf("Employee %s is now busy doing whatever a %s is doing: %s\n", employee->person.name, employee->title, employee->workdescription);
}


Employee* createEmployee(Person*owner, char*name, char*title, char*workdescription, int age)
{
    Employee *newEmployee = (Employee*)malloc(sizeof(Employee));
    
    newEmployee->person.owner = owner;
    newEmployee->person.dowork = (work)employee_work;

    strcpy(newEmployee->person.name, name);
    newEmployee->person.age = age;
    strcpy(newEmployee->title, title);
    strcpy(newEmployee->workdescription, workdescription);
    
    return newEmployee;
}

Manager* createManager(Person*owner, char*name, char*title, int age)
{
    Manager *newManager = (Manager*)malloc(sizeof(Manager));
    newManager->person.owner=owner;
    newManager->person.dowork = (work)manager_work;
    
    strcpy(newManager->person.name, name);
    newManager->person.age = age;
    strcpy(newManager->title, title);
    
    return newManager;
}



int main(int argc, const char * argv[])
{
    Person *theOwnr = (Person*)createManager(NULL, "Jack Owner", "Founder", 56);
    Person *theBoss = (Person*)createManager(theOwnr, "John Boss", "Supermanager", 22);
    Person *theDude = (Person*)createEmployee(theBoss, "Jim Worker", "Code monkey", "Produce code as fast as hell", 43);
    
    theOwnr->dowork(theOwnr);
    theBoss->dowork(theBoss);
    theDude->dowork(theDude);

    free(theOwnr);
    free(theBoss);
    free(theDude);

    return 0;
}

Edit: ett enklare "frukt"-exempel:

Kod: Markera allt

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef void (*describe)(void*);

typedef struct {

    describe describe;
    
} Fruit;

typedef struct
{
    Fruit fruit;
    
} Apple;


typedef struct
{
    Fruit fruit;
    
} Banana;

typedef struct
{
    Fruit fruit;
    
} Orange;



void describe_apple(Apple*apple)
{
    printf("An apple is round, either green or red. It does not have to be pealed\n");
}

void describe_banana(Banana*banane)
{
    printf("A banana is yellow, long and slightly curved and needs to be pealed before eating\n");
}

void describe_orange(Orange*orange)
{
    printf("An orange is round and orange, it needs to be pealed before eating\n");
}


Apple* createApple()
{
    Apple *apple = (Apple*)malloc(sizeof(Apple));
    apple->fruit.describe = (describe)describe_apple;
    
    return apple;
}

Banana* createBanana()
{
    Banana *banana = (Banana*)malloc(sizeof(Banana));
    banana->fruit.describe = (describe)describe_banana;
    
    return banana;
}

Orange* createOrange()
{
    Orange *orange = (Orange*)malloc(sizeof(Orange));
    orange->fruit.describe = (describe)describe_orange;
    
    return orange;
}


int main(int argc, const char * argv[])
{
    Fruit* fruit1 = (Fruit*)createApple();
    Fruit* fruit2 = (Fruit*)createBanana();
    Fruit* fruit3 = (Fruit*)createOrange();
    
    fruit1->describe(fruit1);
    fruit2->describe(fruit2);
    fruit3->describe(fruit3);

    free(fruit1);
    free(fruit2);
    free(fruit3);
    

    return 0;
}

How!
Häftigt.
Så man kan alltså skriva objektorienterat igenom att använda struct, pekare och funktioner tillsammans?

Jag ser att du programmerar i C99. Den nya C11 standarden så behöver du inte "int argc, const char * argv[]"

[Mr Andersson]

'int main(void)' är tillåten i alla C-versioner, likväl som (argc,argv). Det är ingenting som är specifikt för C11.
C99 säger t.o.m att deklarationen av main kan se ut exakt hur som helst. Men det är bara int(void) och int(argc,argv) som du kan garantera fungerar i alla implementationer.

[Al_Bundy]

En rolig sak att veta är att for-loop finns inte i C11-standarden.

Varför? Jag har ingen aning.

[TomasL]

Var har du fått det ifrån att C11 inte stöder For-loop

[Mr Andersson]

Var det där ett försök att skämta eller är du så där ignorant på riktigt? Jag ser dig posta nonsens i tråd efter tråd utan att ens försöka ta reda på saker själv.

6.8.5.3 är allt jag har att säga om for-loopar.

[Al_Bundy]

Det var någon C-tutorial på tuben där användaren använde Code::blocks och då fick man lägga till C99 For-loop i ett visst undantag.

[TomasL]

AL, snälla ta reda på hur saker förhåller sig, innan du kommer med en massa påståenden, tror inte du har en aning om vad tube-klippet handlade om.
Från standarden:

Kod: Markera allt

6.4.1 Keywords
Syntax
1 keyword: one of
auto ∗
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
inline
int
long
register
restrict
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
_Alignas
_Alignof
_Atomic
_Bool
_Complex
_Generic
_Imaginary
_Noreturn
_Static_assert
_Thread_local

[Al_Bundy]

Eller så var det tvärt om.
I alla fall så hade denna person samma problem.
http://stackoverflow.com/questions/2488 ... -gcc-error

[sodjan]

Vad syftar "samma problem" på ??
Problemet i *den* tråden var for loop med oinitierad loop-variabel,
vilket inte har ett smack med om for loopar stöds ellet inte.

[Al_Bundy]

Då har jag väll tolkat fel. I code:bllocks så skulle man skriva in std=-99 har jag för mig. Det var länge sedan jag gjorde det.

[Mr Andersson]

Sodjan; Blir det fel syntax är det aldrig fel på den som skrev koden. Det är ju språket som är trasigt

[sodjan]

> så skulle man skriva in std=-99

Men var har det med att "for-loop finns inte i C11-standarden." ?
Jo, du hade nog missuppfattat det hela...

[MiaM]

Om man snävar till kraven att man skall kunna skriva lågnivådrivrutiner själv i kompilatorn _utan_ stöd av andra produkter än det som kommer med en standard kompilatormiljö (ok assembler är tillåten för tex inline-assembler i språket eller för dom första byten startuppkod, om den finns i kompilatormiljön från början), hur många då kan hacka lågnivå med direkt HW-adressering etc. på något så när strukturerat sätt (dvs. lite mer kontrollerat än peek och poke ala basic) ??

Man kan ju inte ens vara helt säker på att C går att använda. Det är väl t.ex. inte alls självklart att en C-kompilator stöder att man klämmer på flaggor som talar om att en funktion ska köras som interuptrutin (d.v.s. oftast göra speciella saker med register, ofta ha speciell återhoppinstruktion o.s.v.)

Nej, det är nog snarast så att det är vanligt att C-kompilatorer lämpar sig för hårdvarunära programmering, medan det hos kompilatorer för andra språk inte är lika vanligt.

[TomasL]

Huruvida en kompilator. Oavsett språk sröder hw beror väl på biblioteken och porteringen, och inget annat

[MiaM]

Ja, ungefär, fast C har ett par funktioner i sig som gör att man kommer närmare hårdvaran.

Man kan t.ex. tilldela pekare absolutvärden (både för variabelpekare och funktionspekare), och det finns rikligt med datatyper som är lagom löst definerade. Därmed går det lätt att låta datatyperna stämma överens med de olika bussbredder på hårdvaruaccesser som finns, och man kan se till att pekarnas värden motsvarar fysiska adresser.

Om man t.ex. har klassisk textläges-bildhårdvara i en enkel dator så kan man deklarera en pekare till en array typ[80][25] (eller var det tvärt om?) och tilldela den till starten av skrämminnet. Då kan man skriva/läsa valfritt tecken på skärmen på samma sätt som man läser/skriver ett värde i en array.

I princip är det nära på direkt krångligt att göra en C-kompilator som INTE stöder hårdvarunära programmering.

Det som kan sätta krokben är om den som skrivit kompilatorn inte riktigt brytt sig om volatile-deklarationsmöjligheten så att accesser av hårdvaruregister sker på märkligt sätt.

Det går för övrigt att "skriva" maskinkodsnuttar i C genom att helt enkelt radda upp en hexdump i en array och använda arrayens adress som en funktionspekare. För att omöjliggöra detta krävs i princip också aktivt extrajobb från den som skriver kompilatorn.

De flesta andra språk har mer omfattande kontroller i den mån de över huvud taget hanterar pekare som i C, och då krävs specifika workarounds för att göra de trick som man får på köpet i C.

Å andra sidan leder detta till att det oftare dyker upp säkerhetsluckor i C-kod än i andra språk.