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 (sic)(en Français dans le texte) */ 
    tmp=malloc(1024*sizeof(char)); /* cast supprimé */ 
    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