Apprendre la programmation en C.

Code:


./prog(panic+0x1f)[0x557a1ffe194f]
./prog(this_is_an_error+0xe)[0x557a1ffe197c]
./prog(main+0xe)[0x557a1ffe198d]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf1)[0x7fa0bb5982b1]
./prog(_start+0x2a)[0x557a1ffe182a]


le programme C:

Code:


./prog(+0x745)[0x561ea61a6745]
./prog(+0x5eb)[0x561ea61a65eb]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf1)[0x7f61c6e2b2b1]
./prog(+0x62a)[0x561ea61a662a]


Code:


//https://stackoverflow.com/questions/6338244/gcc-conditional-compilation
// gcc main.c -o prog -DENV_TEST   ---> environnement de test
// gcc main.c -o prog ---> environnement de production

#include <stdio.h>

int main (){
#ifdef ENV_TEST
 printf("Environnement de TEST\n");
#else
 printf("Environnement de PRODUCTION\n");
#endif
 return 0;
}



Code:


>gcc main.c -o prog -DENV_TEST
>./prog
>Environnement de TEST


Code:


>gcc main.c -o prog
>./prog
>Environnement de PRODUCTION


Code:


#include <stdio.h>
int main(){
 int a=1;
 // Does this print 2??/
 a++;
 printf("La valeur de a est %i\n",a);
 return 0;
}



./prog ...:

Roger a écrit:
Commencer la programmation avec du C, c'est du suicide. Il faut  toujours apprendre avec un souci de rigueur, donc avec des outils bien fondés, avec une sémantique univoque et bien maîtrisée. Cela permet de plus d'apprendre ce qu'est une sémantique, ce que la quasi-totalité des programmeurs ignore (un désastre en pratique; les audits annuels du Standish Group pointe du doigt la baisse de qualité des logiciels et leur coût ahurissant pour la collectivité).

Roger a écrit:Php, Python, C, C++, Java, Javascript => poubelle.

Roger a écrit:
Le C n'est pas minimaliste du tout: la dernière norme fait 683 pages !

SMALL! You can compile and execute C code everywhere, for example on rescue disks (about 100KB for x86 TCC executable, including C preprocessor, C compiler, assembler and linker).

FAST! tcc generates x86 code. No byte code overhead. Compile, assemble and link several times faster than GCC.
UNLIMITED! Any C dynamic library can be used directly. TCC is heading torward full ISOC99 compliance. TCC can of course compile itself.

TinyCC  : 859000 lines/second 29.6 Mb/s

Petitagore a écrit:
Si je mets Javascript à la poubelle, il ne me reste absolument rien pour faire tourner un algorithme si simple soit-il dans une page web... et c'est quand même un peu limitant en l'an 2017. Sauf à envisager la conversion automatique en Javascript d'une démarche logique définie avec un autre langage. Je me suis laissé dire qu'on pouvait faire ça avec du OCaml, mais ça ne m'a vraiment pas l'air d'être une pratique très répandue. Tu fais ça, toi?

Petitagore a écrit:C'est intéressant, Stauk, merci de me l'apprendre. Ca m'a quand même l'air d'être encore à l'état de prototype.

Stauk a écrit:... J'ai besoin d'un langage qui me laisse ouvert l'option d'accéder aux aspects bas niveau.

...Par comparaison le C demande 6h chrono en main pour en faire le tour. Easy to learn, hard (impossible) to master.

Roger a écrit:Quand on veut faire le l'algorithmique sérieuse, on ne se met pas des boulets aux pieds. On a autre chose à faire que de gérer les malloc et les free, par exemple. On a d'autres soucis que d'assurer à la main la compatibilité des types de données atomiques.

Philippe a écrit:pour apprendre à programmer (en général) je recommanderais un langage « venant des maths » donc fonctionnel, probablement Haskell, ou OCaML.

Dans les vieillerie,:

Roger a écrit:

Stauk a écrit:

Roger a écrit:
Le C n'est pas minimaliste du tout: la dernière norme fait 683 pages !

Bah écoute, quand on peut écrire un compilateur en 100Ko tout inclus, je dis que c'est minimaliste.

Tu as perdu tout sens des réalités ou alors tu es très très jeune. Un compilateur de 100ko ne tiendrait même pas dans la mémoire vive d'une machine des années 70: UNIX a été conçu sur un PDP-7, dont la mémoire typique était de 9ko. Il y a des implémentations de Forth qui font moins de 1ko. Pour le minimalisme, tu repasseras.

TinyCC  : 859000 lines/second 29.6 Mb/s

TinyCC n'est pas aux normes et a été conçu à la base (OTCC) pour faire de l'obfuscation de code. Très mauvais exemple. Tu me confortes dans ma position.

le programme que tu nous proposes:

Code:


#include <stdio.h>
#define SIZE 10
int main(){
 int i;
 for(i=0;i<SIZE;i++){
 printf("%i\n",i);
 }
 return 0;
}


Code:


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

#define SIZE 10

int main(void) {
  int *tab = malloc(SIZE * (sizeof (int)));
  int i;

  for(i=0;i<SIZE;i++) {
    tab[i] = i;
  }

  for (i=0;i<SIZE;i++) {
    printf("%d\n", tab[i]);
  }
  free(tab);
  return EXIT_SUCCESS;
}


Stauk a écrit:Naturellement si tu cherchais à nous convaincre que C permet d'écrire des programmes qui plantent, ou qui sont non-maintenables, ton exemple est bien choisi.

Stauk a écrit:Et je ne dis pas ça pour convaincre qui que ce soit d'apprendre le C en espérant en retirer autre chose qu'une connaissance historique de l'informatique. Car les arguments qui ont été donnés ici en défaveur de ce langage sont très pertinents. Comme ce lien https://www.developpez.com/actu/172666/Quel-avenir-pour-le-langage-C-Un-developpeur-experimente-fait-ses-adieux-au-langage-et-livre-ses-inquietudes-quant-a-son-avenir/     .

7. Conclusion
I have reviewed the inspiration, implementation, and implications of the ALA model
for computing. It is based on a belief that a fundamental error was made when computer
science diverged from physical science; by basing the foundations of the former
on those of the latter, hardware and software can be aligned at all levels of description.
I’ve argued that this is not just possible, it is preferable to address many of the
issues in scaling information technologies. Interconnect bottlenecks, challenges in
multicore compilation, quiescent power budgets, and diverging chip design costs are
all symptoms of trying to compute in a world that differs from the one that we actually
live in. These problems are simplified by explicitly recognizing time, space, state, and
logic as coupled properties of a medium in which computing happens

Roger a écrit:
Bellard fait ce qui lui plaît. C'est son problème. Tu l'as lu le code de OTCC ? Tu l'as vraiment lu ? Tu crois vraiment que tu peux apprendre à programmer avec ça ? Dis-moi que c'est une blague !

ou Bellard dont les hauts faits consistent à écrire des programmes illisibles.

Bellard a écrit:
December 31st, 2009

I am pleased to announce a new world record for the computation of the digits of Pi. The following number of digits were computed:

 2242301460000 hexadecimal digits (base 16)
 2699999990000 decimal digits (base 10)
The base 10 result needs about 1137 GB(1) of storage. Parts of the result are available here.
Most of the computation was carried out on a single desktop computer costing less than 2000 euros. The previous records since 1995 were done using multi-million euro supercomputers.

Roger a écrit:
Prend-moi pour un con, j'aime bien

Voilà, tu continues à reluquer mon doigt. Le trouves-tu trop grand, trop gros ou trop vigoureux à ton goût.

Avec un peu de chance, tu feras exploser une fusée ou tu tueras quelques cancéreux avec tes programmes pourris.

j'ai vu des projets à plusieurs centaines de millions d'euros - oui, des centaines de millions d'euros ! - se vautrer complètement du fait d'incompétents qui se prennent pour des W1z@rdZ.

Roger a écrit:
Je sais ce qui arrivera

Code:

/*
  Obfuscated Tiny C Compiler

  Copyright (C) 2001-2003 Fabrice Bellard

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product and its documentation
     *is* required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/
#ifndef TINY
#include <stdarg.h>
#endif
#include <stdio.h>

/* vars: value of variables
   loc : local variable index
   glo : global variable index
   ind : output code ptr
   rsym: return symbol
   prog: output code
   dstk: define stack
   dptr, dch: macro state
*/
int tok, tokc, tokl, ch, vars, rsym, prog, ind, loc, glo, file, sym_stk, dstk, dptr, dch, last_id;

#define ALLOC_SIZE 99999

/* depends on the init string */
#define TOK_STR_SIZE 48
#define TOK_IDENT    0x100
#define TOK_INT      0x100
#define TOK_IF       0x120
#define TOK_ELSE     0x138
#define TOK_WHILE    0x160
#define TOK_BREAK    0x190
#define TOK_RETURN   0x1c0
#define TOK_FOR      0x1f8
#define TOK_DEFINE   0x218
#define TOK_MAIN     0x250

#define TOK_DUMMY   1
#define TOK_NUM     2

#define LOCAL   0x200

#define SYM_FORWARD 0
#define SYM_DEFINE  1

/* tokens in string heap */
#define TAG_TOK    ' '
#define TAG_MACRO  2

pdef(t)
{
    *(char *)dstk++ = t;
}

inp()
{
    if (dptr) {
        ch = *(char *)dptr++;
        if (ch == TAG_MACRO) {
            dptr = 0;
            ch = dch;
        }
    } else
        ch = fgetc(file);
    /*    printf("ch=%c 0x%x\n", ch, ch); */
}

isid()
{
    return isalnum(ch) | ch == '_';
}

/* read a character constant */
getq()
{
    if (ch == '\\') {
        inp();
        if (ch == 'n')
            ch = '\n';
    }
}

next()
{
    int t, l, a;

    while (isspace(ch) | ch == '#') {
        if (ch == '#') {
            inp();
            next();
            if (tok == TOK_DEFINE) {
                next();
                pdef(TAG_TOK); /* fill last ident tag */
                *(int *)tok = SYM_DEFINE;
                *(int *)(tok + 4) = dstk; /* define stack */
            }
            /* well we always save the values ! */
            while (ch != '\n') {
                pdef(ch);
                inp();
            }
            pdef(ch);
            pdef(TAG_MACRO);
        }
        inp();
    }
    tokl = 0;
    tok = ch;
    /* encode identifiers & numbers */
    if (isid()) {
        pdef(TAG_TOK);
        last_id = dstk;
        while (isid()) {
            pdef(ch);
            inp();
        }
        if (isdigit(tok)) {
            tokc = strtol(last_id, 0, 0);
            tok = TOK_NUM;
        } else {
            *(char *)dstk = TAG_TOK; /* no need to mark end of string (we
                                        suppose data is initied to zero */
            tok = strstr(sym_stk, last_id - 1) - sym_stk;
            *(char *)dstk = 0;   /* mark real end of ident for dlsym() */
            tok = tok * 8 + TOK_IDENT;
            if (tok > TOK_DEFINE) {
                tok = vars + tok;
                /*        printf("tok=%s %x\n", last_id, tok); */
                /* define handling */
                if (*(int *)tok == SYM_DEFINE) {
                    dptr = *(int *)(tok + 4);
                    dch = ch;
                    inp();
                    next();
                }
            }
        }
    } else {
        inp();
        if (tok == '\'') {
            tok = TOK_NUM;
            getq();
            tokc = ch;
            inp();
            inp();
        } else if (tok == '/' & ch == '*') {
            inp();
            while (ch) {
                while (ch != '*')
                    inp();
                inp();
                if (ch == '/')
                    ch = 0;
            }
            inp();
            next();
        } else
        {
            t = "++#m--%am*@R<^1c/@%[_[H3c%@%[_[H3c+@.B#d-@%:_^BKd<<Z/03e>>`/03e<=0f>=/f<@.f>@1f==&g!=\'g&&k||#l&@.BCh^@.BSi|@.B+j~@/%Yd!@&d*@b";
            while (l = *(char *)t++) {
                a = *(char *)t++;
                tokc = 0;
                while ((tokl = *(char *)t++ - 'b') < 0)
                    tokc = tokc * 64 + tokl + 64;
                if (l == tok & (a == ch | a == '@')) {
#if 0
                    printf("%c%c -> tokl=%d tokc=0x%x\n",
                           l, a, tokl, tokc);
#endif
                    if (a == ch) {
                        inp();
                        tok = TOK_DUMMY; /* dummy token for double tokens */
                    }
                    break;
                }
            }
        }
    }
#if 0
    {
        int p;

        printf("tok=0x%x ", tok);
        if (tok >= TOK_IDENT) {
            printf("'");
            if (tok > TOK_DEFINE)
                p = sym_stk + 1 + (tok - vars - TOK_IDENT) / 8;
            else
                p = sym_stk + 1 + (tok - TOK_IDENT) / 8;
            while (*(char *)p != TAG_TOK && *(char *)p)
                printf("%c", *(char *)p++);
            printf("'\n");
        } else if (tok == TOK_NUM) {
            printf("%d\n", tokc);
        } else {
            printf("'%c'\n", tok);
        }
    }
#endif
}

#ifdef TINY
#define skip(c) next()
#else

void error(char *fmt,...)
{
    va_list ap;

    va_start(ap, fmt);
    fprintf(stderr, "%d: ", ftell((FILE *)file));
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    exit(1);
    va_end(ap);
}

void skip(c)
{
    if (tok != c) {
        error("'%c' expected", c);
    }
    next();
}

#endif

o(n)
{
    /* cannot use unsigned, so we must do a hack */
    while (n && n != -1) {
        *(char *)ind++ = n;
        n = n >> 8;
    }
}

/* output a symbol and patch all calls to it */
gsym(t)
{
    int n;
    while (t) {
        n = *(int *)t; /* next value */
        *(int *)t = ind - t - 4;
        t = n;
    }
}

/* psym is used to put an instruction with a data field which is a
   reference to a symbol. It is in fact the same as oad ! */
#define psym oad

/* instruction + address */
oad(n, t)
{
    o(n);
    *(int *)ind = t;
    t = ind;
    ind = ind + 4;
    return t;
}

/* load immediate value */
li(t)
{
    oad(0xb8, t); /* mov $xx, %eax */
}

gjmp(t)
{
    return psym(0xe9, t);
}

/* l = 0: je, l == 1: jne */
gtst(l, t)
{
    o(0x0fc085); /* test %eax, %eax, je/jne xxx */
    return psym(0x84 + l, t);
}

gcmp(t)
{
    o(0xc139); /* cmp %eax,%ecx */
    li(0);
    o(0x0f); /* setxx %al */
    o(t + 0x90);
    o(0xc0);
}

gmov(l, t)
{
    o(l + 0x83);
    oad((t < LOCAL) << 7 | 5, t);
}

/* l is one if '=' parsing wanted (quick hack) */
unary(l)
{
    int n, t, a, c;

    n = 1; /* type of expression 0 = forward, 1 = value, other =
              lvalue */
    if (tok == '"') {
        li(glo);
        while (ch != '"') {
            getq();
            *(char *)glo++ = ch;
            inp();
        }
        *(char *)glo = 0;
        glo = glo + 4 & -4; /* align heap */
        inp();
        next();
    } else {
        c = tokl;
        a = tokc;
        t = tok;
        next();
        if (t == TOK_NUM) {
            li(a);
        } else if (c == 2) {
            /* -, +, !, ~ */
            unary(0);
            oad(0xb9, 0); /* movl $0, %ecx */
            if (t == '!')
                gcmp(a);
            else
                o(a);
        } else if (t == '(') {
            expr();
            skip(')');
        } else if (t == '*') {
            /* parse cast */
            skip('(');
            t = tok; /* get type */
            next(); /* skip int/char/void */
            next(); /* skip '*' or '(' */
            if (tok == '*') {
                /* function type */
                skip('*');
                skip(')');
                skip('(');
                skip(')');
                t = 0;
            }
            skip(')');
            unary(0);
            if (tok == '=') {
                next();
                o(0x50); /* push %eax */
                expr();
                o(0x59); /* pop %ecx */
                o(0x0188 + (t == TOK_INT)); /* movl %eax/%al, (%ecx) */
            } else if (t) {
                if (t == TOK_INT)
                    o(0x8b); /* mov (%eax), %eax */
                else
                    o(0xbe0f); /* movsbl (%eax), %eax */
                ind++; /* add zero in code */
            }
        } else if (t == '&') {
            gmov(10, *(int *)tok); /* leal EA, %eax */
            next();
        } else {
            n = *(int *)t;
            /* forward reference: try dlsym */
            if (!n)
                n = dlsym(0, last_id);
            if (tok == '=' & l) {
                /* assignment */
                next();
                expr();
                gmov(6, n); /* mov %eax, EA */
            } else if (tok != '(') {
                /* variable */
                gmov(8, n); /* mov EA, %eax */
                if (tokl == 11) {
                    gmov(0, n);
                    o(tokc);
                    next();
                }
            }
        }
    }

    /* function call */
    if (tok == '(') {
        if (n == 1)
            o(0x50); /* push %eax */

        /* push args and invert order */
        a = oad(0xec81, 0); /* sub $xxx, %esp */
        next();
        l = 0;
        while(tok != ')') {
            expr();
            oad(0x248489, l); /* movl %eax, xxx(%esp) */
            if (tok == ',')
                next();
            l = l + 4;
        }
        *(int *)a = l;
        next();
        if (!n) {
            /* forward reference */
            t = t + 4;
            *(int *)t = psym(0xe8, *(int *)t);
        } else if (n == 1) {
            oad(0x2494ff, l); /* call *xxx(%esp) */
            l = l + 4;
        } else {
            oad(0xe8, n - ind - 5); /* call xxx */
        }
        if (l)
            oad(0xc481, l); /* add $xxx, %esp */
    }
}

sum(l)
{
    int t, n, a;

    if (l-- == 1)
        unary(1);
    else {
        sum(l);
        a = 0;
        while (l == tokl) {
            n = tok;
            t = tokc;
            next();

            if (l >  {
                a = gtst(t, a); /* && and || output code generation */
                sum(l);
            } else {
                o(0x50); /* push %eax */
                sum(l);
                o(0x59); /* pop %ecx */
                
                if (l == 4 | l == 5) {
                    gcmp(t);
                } else {
                    o(t);
                    if (n == '%')
                        o(0x92); /* xchg %edx, %eax */
                }
            }
        }
        /* && and || output code generation */
        if (a && l >  {
            a = gtst(t, a);
            li(t ^ 1);
            gjmp(5); /* jmp $ + 5 */
            gsym(a);
            li(t);
        }
    }
}

expr()
{
    sum(11);
}


test_expr()
{
    expr();
    return gtst(0, 0);
}

block(l)
{
    int a, n, t;

    if (tok == TOK_IF) {
        next();
        skip('(');
        a = test_expr();
        skip(')');
        block(l);
        if (tok == TOK_ELSE) {
            next();
            n = gjmp(0); /* jmp */
            gsym(a);
            block(l);
            gsym(n); /* patch else jmp */
        } else {
            gsym(a); /* patch if test */
        }
    } else if (tok == TOK_WHILE | tok == TOK_FOR) {
        t = tok;
        next();
        skip('(');
        if (t == TOK_WHILE) {
            n = ind;
            a = test_expr();
        } else {
            if (tok != ';')
                expr();
            skip(';');
            n = ind;
            a = 0;
            if (tok != ';')
                a = test_expr();
            skip(';');
            if (tok != ')') {
                t = gjmp(0);
                expr();
                gjmp(n - ind - 5);
                gsym(t);
                n = t + 4;
            }
        }
        skip(')');
        block(&a);
        gjmp(n - ind - 5); /* jmp */
        gsym(a);
    } else if (tok == '{') {
        next();
        /* declarations */
        decl(1);
        while(tok != '}')
            block(l);
        next();
    } else {
        if (tok == TOK_RETURN) {
            next();
            if (tok != ';')
                expr();
            rsym = gjmp(rsym); /* jmp */
        } else if (tok == TOK_BREAK) {
            next();
            *(int *)l = gjmp(*(int *)l);
        } else if (tok != ';')
            expr();
        skip(';');
    }
}

/* 'l' is true if local declarations */
decl(l)
{
    int a;

    while (tok == TOK_INT | tok != -1 & !l) {
        if (tok == TOK_INT) {
            next();
            while (tok != ';') {
                if (l) {
                    loc = loc + 4;
                    *(int *)tok = -loc;
                } else {
                    *(int *)tok = glo;
                    glo = glo + 4;
                }
                next();
                if (tok == ',')
                    next();
            }
            skip(';');
        } else {
            /* patch forward references (XXX: do not work for function
               pointers) */
            gsym(*(int *)(tok + 4));
            /* put function address */
            *(int *)tok = ind;
            next();
            skip('(');
            a = 8;
            while (tok != ')') {
                /* read param name and compute offset */
                *(int *)tok = a;
                a = a + 4;
                next();
                if (tok == ',')
                    next();
            }
            next(); /* skip ')' */
            rsym = loc = 0;
            o(0xe58955); /* push   %ebp, mov %esp, %ebp */
            a = oad(0xec81, 0); /* sub $xxx, %esp */
            block(0);
            gsym(rsym);
            o(0xc3c9); /* leave, ret */
            *(int *)a = loc; /* save local variables */
        }
    }
}

main(n, t)
{
    file = stdin;
    if (n-- > 1) {
        t = t + 4;
        file = fopen(*(int *)t, "r");
    }
    dstk = strcpy(sym_stk = calloc(1, ALLOC_SIZE),
                  " int if else while break return for define main ") + TOK_STR_SIZE;
    glo = calloc(1, ALLOC_SIZE);
    ind = prog = calloc(1, ALLOC_SIZE);
    vars = calloc(1, ALLOC_SIZE);
    inp();
    next();
    decl(0);
#ifdef TEST
    {
        FILE *f;
        f = fopen(*(char **)(t + 4), "w");
        fwrite((void *)prog, 1, ind - prog, f);
        fclose(f);
        return 0;
    }
#else
    return (*(int (*)())*(int *)(vars + TOK_MAIN)) (n, t);
#endif
}

Stauk a écrit:@Sarella : je veux apprendre à utiliser le C pour réaliser un (ou des) projets de moyenne taille (Durée = 3 mois à 2 ans /homme), maintenables. Maintenable étant ici défini comme les process qui permettent d'optimiser au mieux la gestion de la vie d'un projet réalisé par une ou deux personnes, sur une durée de 2 à 4 ans avec des évolutions régulières nécessaires sur toute la période. Je veux que le temps de gestion des évolutions ne soit pas bouffé par le temps de recherche et correction des bugs. En clair l'idée est d'éviter au maximum la classe des bugs dits "non-reproductibles", et ceci en utilisant le langage C (qui est réputé pour justement avoir la propriété de faciliter l'existence des bugs non-reproductibles).  Les projets seront multithreadés.

Petitagore a écrit:Si ça continue, les fils sur la programmation vont donner autant de boulot aux modos que ceux sur la religion...

Sarella a écrit:
Est-ce que tes projets ont besoin de perf ?

Spoiler:

This article presents the “RISCuva1” processor, a
very simple 8-bit RISC processor for FPGA. Its most
important feature is that this processor is very simple. Its
Verilog code has about 120 sentences, and most of them
are easy to understand. It would be a good starting point
for students who need to know how processors work and
for those engineers who wish to design their own
processor. The proposed processor has been physically
tested on Xilinx SpartanIIe FPGAs with a performance
of 40 MIPS in -6C grade devices.

Stauk a écrit:Mon objectif actuel est d'être capable d'écrire des prototypes qui tournent à la fois sous windows et linux, et qui donnent accès à la souris au clavier et à l'écran.