Le langage de programmation C pour les experts

Les différentes versions du programme qui affiche "HELLO WORLD" suivant les compétences

1
2
10 PRINT "HELLO WORLD"
20 END

1
2
3
4
program HELLO(input, output)
begin
    writeln('HELLO WORLD')
end.

1
2
3
4
5
(defun HELLO
 (print
  (cons 'HELLO (list 'WORLD))
 )
)

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
void main(void)
{
    char *message[] = {"HELLO ", "WORLD"};
     int i;
 
    for(i = 0; i < 2; ++i)
        printf("%s", message[i]);
    printf("\n");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <iostream>
#include <cstring>
using namespace std;
class string
{
private:
    int size;
    char *ptr;
public:
    string() : size(0), ptr(new char('\0')) {}
    string(const string &s) : size(s.size)
    {
        ptr = new char[size + 1];
        strcpy(ptr, s.ptr);
    }
    ~string()
    {
        delete [] ptr;
    }
    friend ostream &operator <<(ostream &, const string &);
    string &operator=(const char *);
};
 
ostream &operator<<(ostream &stream, const string &s)
{
    return(stream << s.ptr);
}
string &string::operator=(const char *chrs)
{
    if (this != &chrs)
    {
        delete [] ptr;
        size = strlen(chrs);
        ptr = new char[size + 1];
        strcpy(ptr, chrs);
    }
    return(*this);
}
int main()
{
    string str;
    str = "HELLO WORLD";
    cout << str << endl;
    return(0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 [
 uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
 ]
 library LHello
 {
     // bring in the master library
     importlib("actimp.tlb");
     importlib("actexp.tlb");

     // bring in my interfaces
     #include "pshlo.idl"

     [
     uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
     ]
     cotype THello
  {
  interface IHello;
  interface IPersistFile;
  };
 };

 [
 exe,
 uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
 ]
 module CHelloLib
 {

     // some code related header files
     importheader();
     importheader();
     importheader();
     importheader("pshlo.h");
     importheader("shlo.hxx");
     importheader("mycls.hxx");

     // needed typelibs
     importlib("actimp.tlb");
     importlib("actexp.tlb");
     importlib("thlo.tlb");

     [
     uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
     aggregatable
     ]
     coclass CHello
  {
  cotype THello;
  };
 };

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "ipfix.hxx"
 
 extern HANDLE hEvent;
 
 class CHello : public CHelloBase
 {
 public:
     IPFIX(CLSID_CHello);
 
     CHello(IUnknown *pUnk);
     ~CHello();
 
     HRESULT  __stdcall PrintSz(LPWSTR pwszString);
 
 private:
     static int cObjRef;
 };

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 // ? #include 
 // ? #include 
 // ? #include 
 // ? #include 
 #include "thlo.h"
 #include "pshlo.h"
 #include "shlo.hxx"
 #include "mycls.hxx"
 
 int CHello::cObjRef = 0;
 
 CHello::CHello(IUnknown *pUnk) : CHelloBase(pUnk)
 {
     cObjRef++;
     return;
 }
 
 HRESULT  __stdcall  CHello::PrintSz(LPWSTR pwszString)
 {
     printf("%ws\n", pwszString);
     return(ResultFromScode(S_OK));
 }
 
 
 CHello::~CHello(void)
 {
 
 // when the object count goes to zero, stop the server
 cObjRef--;
 if( cObjRef == 0 )
     PulseEvent(hEvent);
 
 return;
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 // ? #include 
 // ? #include 
 #include "pshlo.h"
 #include "shlo.hxx"
 #include "mycls.hxx"
 
 HANDLE hEvent;
 
  int _cdecl main(
 int argc,
 char * argv[]
 ) {
 ULONG ulRef;
 DWORD dwRegistration;
 CHelloCF *pCF = new CHelloCF();
 
 hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
 // Initialize the OLE libraries
 CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
 CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
     REGCLS_MULTIPLEUSE, &dwRegistration);
 
 // wait on an event to stop
 WaitForSingleObject(hEvent, INFINITE);
 
 // revoke and release the class object
 CoRevokeClassObject(dwRegistration);
 ulRef = pCF->Release();
 
 // Tell OLE we are going away.
 CoUninitialize();
 
 return(0); }
 
 extern CLSID CLSID_CHello;
 extern UUID LIBID_CHelloLib;
 
 CLSID CLSID_CHello = { /* 2573F891-CFEE-101A-9A9F-00AA00342820 */
     0x2573F891,
     0xCFEE,
     0x101A,
     { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
 };
 
 UUID LIBID_CHelloLib = { /* 2573F890-CFEE-101A-9A9F-00AA00342820 */
     0x2573F890,
     0xCFEE,
     0x101A,
     { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
 };

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 // ? #include 
 // ? #include 
 // ? #include 
 // ? #include 
 // ? #include 
 #include "pshlo.h"
 #include "shlo.hxx"
 #include "clsid.h"
 
 int _cdecl main(
 int argc,
 char * argv[]
 ) {
 HRESULT  hRslt;
 IHello        *pHello;
 ULONG  ulCnt;
 IMoniker * pmk;
 WCHAR  wcsT[_MAX_PATH];
 WCHAR  wcsPath[2 * _MAX_PATH];
 
 // get object path
 wcsPath[0] = '\0';
 wcsT[0] = '\0';
 if( argc > 1) {
     mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
     wcsupr(wcsPath);
     }
 else {
     fprintf(stderr, "Object path must be specified\n");
     return(1);
     }
 
 // get print string
 if(argc > 2)
     mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
 else
     wcscpy(wcsT, L"Hello World");
 
 printf("Linking to object %ws\n", wcsPath);
 printf("Text String %ws\n", wcsT);
 
 // Initialize the OLE libraries
 hRslt = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
 if(SUCCEEDED(hRslt)) {
 
 
     hRslt = CreateFileMoniker(wcsPath, &pmk);
     if(SUCCEEDED(hRslt))
  hRslt = BindMoniker(pmk, 0, IID_IHello, (void **)&pHello);
 
     if(SUCCEEDED(hRslt)) {
 
  // print a string out
  pHello->PrintSz(wcsT);
 
  Sleep(2000);
  ulCnt = pHello->Release();
  }
     else
  printf("Failure to connect, status: %lx", hRslt);
 
     // Tell OLE we are going away.
     CoUninitialize();
     }
 
 return(0);
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
main()
{
    char *tmp;
    int i=0;
    /* on y va bourin [I](sic)(en Français dans le texte)[/I] */
    tmp=malloc(1024*sizeof(char)); /* [I]cast supprimé[/I] */
    while (tmp[i]="HELLO WORLD"[i++]);
    /* Ooopps y'a une infusion ! */
    i=(int)tmp[8];
    tmp[8]=tmp[9];
    tmp[9]=(char)i;
    printf("%s\n",tmp);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/local/bin/perl
$msg="HELLO, WORLD.\n";
if ($#ARGV >= 0) {
    while(defined($arg=shift(@ARGV))) {
        $outfilename = $arg;
        open(FILE, ">" . $outfilename) || die "Can't write $arg: $!\n";
        print (FILE $msg);
        close(FILE) || die "Can't close $arg: $!\n";
 
    }
} else {
    print ($msg);
}
1;

1
2
3
#include <stdio.h>
#define S "HELLO, WORLD\n"
main(){exit(printf(S) == strlen(S) ? 0 : 1);}

1
2
% cc -o a.out ~/src/misc/bv/bv.c
% a.out

1
2
3
% cat
HELLO, WORLD.
^D

1
2
10 PRINT "HELLO WORLD"
20 END

1
2
3
4
5
mail -s "HELLO, WORLD." bob@b12
Henri, pourrais-tu m'écrire un programme qui écrit "HELLO,
WORLD." À l'écran?
J'en ai besoin pour demain.
^D

1
2
% zmail Jean
J'ai besoin d'un programme "HELLO, WORLD." Pour cette après-midi.

1
2
3
4
5
6
7
8
9
% letter
letter: Command not found.
% mail
To: ^X ^F ^C
% help mail
help: Command not found.
% damn!
!: Event unrecognized
% logout