Helló Világ programpéldák
A Wikipédiából, a szabad lexikonból.
Az alábbiakban példákat láthatunk a Helló Világ programokra különböző programozási nyelveken. A megjelenített szöveg a legtöbb helyen ékezetek nélkül, ugyanis bizonyos nyelvek, környezetek és eszközök nem képesek az ékezetek megjelenítésére.
[szerkesztés] Szöveges felhasználói felület
Szöveges felhasználói felületekben (TUI; másnéven konzolban) használt nyelvek példái.
[szerkesztés] ABC
WRITE "Hello Vilag"
[szerkesztés] Ada
with Ada.Text_Io; use Ada.Text_Io;
procedure Hello is
begin
Put_Line ("Hello Vilag!");
end Hello;
[szerkesztés] AmigaE
PROC main()
WriteF('Hello Vilag!')
ENDPROC
[szerkesztés] APL
'Hello Vilag'
[szerkesztés] Assembly nyelv
[szerkesztés] Csak Accumulator architektúra
A csak Accumulator architektúrák: DEC PDP–8, PAL–III összeállító
A példa a Digital PDP–8 Handbook Series, Introduction to Programming könyvből származik.
*200 / összeállítás-származás megadása (betöltési cím)
hello, cla cll
tls / tls a nyomtatójelölő megadásához.
tad charac / indexregiszter beállítása
dca ir1 / a karakterek megszerzéséhez.
tad m6 / számláló beállítása
dca count / a karakterek kiírásához.
next, tad i ir1 / karakter megszerzése.
jms type / kiírása.
isz count / elkészült?
jmp next / nem: újabb begépelése.
hlt
type, 0 / type szubrutin
tsf
jmp .-1
tls
cla
jmp i type
charac, . / az ir1 kezdetleges értéke
310 / H
305 / E
314 / L
314 / L
317 / O
254 / ,
240 /
327 / W
317 / O
322 / R
314 / L
304 / D
241 / !
m6, -15
count, 0
ir1 = 10
$
[szerkesztés] Első sikeres µP/OS-kombinációk
Intel 8080/Zilog Z80, CP/M, RMAC összeállító
bdos equ 0005H ; BDOS belépési pont
start: mvi c,9 ; BDOS függvény: karakterlánc kivitele
lxi d,msg$ ; msg címe
call bdos
ret ; visszatérés a CCP-hez
msg$: db 'Hello Vilag!$'
end start
[szerkesztés] Accumulator + indexregisztergép
MOS Technology 6502, CBM KERNAL, ca65 assembler
MSG: .ASCIIZ "Hello Vilag!"
LDX #0
LDA MSG,X ; kezdőkarakter betöltése
@LP: JSR $FFD2 ; chrout
INX
LDA MSG,X
BNE @LP
RTS
[szerkesztés] Accumulator/Index mikrokódolt gép
Data General Nova, RDOS
; "Helló Világ" program RDOS-t futtató Novára; az eredetit írta: Toby Thain
; PCHAR rendszerhívást használ
.titl hello
.nrel
.ent start
start:
dochar:
lda 0,@pmsg ; ac0 betöltése következő karakterrel,
mov# 0,0,snr ; ac0 tesztelése; kihagyás ha nem nulla (ne töltse be az eredményt)
jmp done
.systm
.pchar ; első kiírása
jmp er ; kihagyva, ha jó
movs 0,0 ; bájtcsere
.systm
.pchar ; második kiírása
jmp er ; kihagyva, ha jó
isz pmsg ; mutatás a következő szóra
jmp dochar ; újrakezdés
done: .systm ; normál kilépés
.rtn
er: .systm ; hibás kilépés
.ertn
halt
pmsg: .+1 ; mutató a karakterlánc első szavához
; a megjegyzésbájtok alapértelmezés szerint jobbról balra vannak csomagolva
.txt /Hello Vilag!<15><12>/ ; CR LF
0 ; szó megjelölése a karakterlánc befejezéséhez
.end start
[szerkesztés] Bővített accumulator gép
MODEL SMALL
IDEAL
STACK 100H
DATASEG
MSG DB 'Hello Vilag!$'
CODESEG
MOV AX, @data
MOV DS, AX
MOV DX, OFFSET MSG
MOV AH, 09H ; DOS: ASCII$ karakterlánc kivitele
INT 21H
MOV AX, 4C00H
INT 21H
END
[szerkesztés] Általános célú fiktív számítógép
MIX, MIXAL
TERM EQU 19 konzoleszköz száma (19 = írógép)
ORIG 1000 címkezdet
START OUT MSG(TERM) adat kivitele a cél-MSG-nél
HLT megszakítás végrehajtása
MSG ALF "HELLO"
ALF " VILA"
ALF "G "
END START program vége
[szerkesztés] Általános célú CISC regiszter
DEC PDP–11, RT-11, MACRO-11
.MCALL .REGDEF,.TTYOUT,.EXIT
.REGDEF
HELLO: MOV #MSG,R1
MOVB (R1),R0
LOOP: .TTYOUT
MOVB +(R1),R0
BNE LOOP
.EXIT
MSG: .ASCIZ /HELLO VILAG!/
.END HELLO
[szerkesztés] CISC irányított többfolyamatos operációs rendszeren
DEC VAX, VMS, MACRO-32
.title hello
.psect data, wrt, noexe
chan: .blkw 1
iosb: .blkq 1
term: .ascid "SYS$OUTPUT"
msg: .ascii "Hello Vilag!"
len = . - msg
.psect code, nowrt, exe
.entry hello, ^m<>
; Csatorna létesítése terminálos I/O-hoz
$assign_s devnam=term, -
chan=chan
blbc r0, end
; I/O-kérelem sorbaállítása
$qiow_s chan=chan, -
func=#io$_writevblk, -
iosb=iosb, -
p1=msg, -
p2=#len
; Állapot és IOSB-állapot ellenőrzése
blbc r0, end
movzwl iosb, r0
; Visszatérés az operációs rendszerhez
end: ret
.end hello
[szerkesztés] RISC processzor
ARM, RISC OS, a BBC BASIC interpretere
.program
ADR R0,message
SWI "OS_Write0"
SWI "OS_Exit"
.message
DCS "Hello Vilag!"
DCB 0
ALIGN
Vagy még kisebb változat (qUE-től):
SWI"OS_WriteS":EQUS"Hello Vilag!":EQUB0:ALIGN:MOVPC,R14
[szerkesztés] Awk
{print "Hello Vilag!"}
[szerkesztés] BASIC
[szerkesztés] CASIO-BASIC - Casio grafikus számológépeken használt BASIC-nyelv
"HELLO VILAG!"
[szerkesztés] MS BASIC (hagyományos, strukturálatlan)
10 PRINT "Hello Vilag!" 20 END
[szerkesztés] TI-BASIC
TI–80–TI–83 számológépeken:
:Disp "Hello Vilag!"
TI–89; TI–92 számológépeken:
:HelloWorld() :Prgm :Disp "Hello Vilag!" :EndPrgm
[szerkesztés] StarOffice/OpenOffice Basic
sub main
print "Hello Vilag!"
end sub
[szerkesztés] Strukturált BASIC
print "Hello Vilag!" end
[szerkesztés] BCPL
GET "LIBHDR"
LET START () BE
$(
WRITES ("Hello Vilag!*N")
$)
[szerkesztés] BLISS
%TITLE 'HELLO_WORLD'
MODULE HELLO_WORLD (IDENT='V1.0', MAIN=HELLO_WORLD,
ADDRESSING_MODE (EXTERNAL=GENERAL)) =
BEGIN
LIBRARY 'SYS$LIBRARY:STARLET';
EXTERNAL ROUTINE
LIB$PUT_OUTPUT;
GLOBAL ROUTINE HELLO_WORLD =
BEGIN
LIB$PUT_OUTPUT(%ASCID %STRING('Hello Vilag!'))
END;
END
ELUDOM
[szerkesztés] C
#include <stdio.h>
int main()
{
printf("Hello Vilag!\n");
return 0;
}
- include<stdio.h>
void main (void)
{
printf(\n Helló világ!\n);
}
[szerkesztés] C++
#include <iostream>
int main()
{
std::cout << "Helló Világ!\n";
}
[szerkesztés] CIL
.method public static void Main() cil managed
{
.entrypoint
.maxstack 8
ldstr "Hello Vilag!"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
[szerkesztés] Clean
module hello Start :: String Start = "Hello Vilag"
[szerkesztés] CLIST
PROC 0 WRITE Hello Vilag!
[szerkesztés] COBOL
IDENTIFICATION DIVISION. PROGRAM-ID. HELLO-WORLD. ENVIRONMENT DIVISION. DATA DIVISION. PROCEDURE DIVISION. DISPLAY "Hello Vilag!". STOP RUN.
[szerkesztés] Common Lisp
(format t "Hello Vilag!~%")
[szerkesztés] D
int main() {
printf("Hello Vilag!\n");
return 0;
}
[szerkesztés] DCL parancsfájl
$ write sys$output "Hello Vilag!"
[szerkesztés] Ed és Ex (Ed extended)
a hello vilag! . p
Vagy:
echo -e 'a\nhello vilag!\n.\np'|ed echo -e 'a\nhello vilag!\n.\np'|ex
[szerkesztés] Eiffel
class HELLO_WORLD
creation
make
feature
make is
local
io:BASIC_IO
do
!!io
io.put_string("%N Hello Vilag!")
end -- make
end -- class HELLO_WORLD
[szerkesztés] Erlang
-module(hello).
-export([hello_world/0]).
hello_world() -> io:fwrite("Hello Vilag!\n").
[szerkesztés] EUPHORIA
puts(1, "Hello Vilag!")
[szerkesztés] F#
type data =
{ first: string;
second: string; }
let myData =
{ first="Hello";
second="Vilag"; }
let _ =
print_string myData.first;
print_string " ";
print_string myData.second;
print_newline()
[szerkesztés] Focus
-TYPE Hello Vilag
[szerkesztés] Forte TOOL
begin TOOL HelloWorld;
includes Framework;
HAS PROPERTY IsLibrary = FALSE;
forward Hello;
-- START CLASS DEFINITIONS
class Hello inherits from Framework.Object
has public method Init;
has property
shared=(allow=off, override=on);
transactional=(allow=off, override=on);
monitored=(allow=off, override=on);
distributed=(allow=off, override=on);
end class;
-- END CLASS DEFINITIONS
-- START METHOD DEFINITIONS
------------------------------------------------------------
method Hello.Init
begin
super.Init();
task.Part.LogMgr.PutLine('HelloVilag!');
end method;
-- END METHOD DEFINITIONS
HAS PROPERTY
CompatibilityLevel = 0;
ProjectType = APPLICATION;
Restricted = FALSE;
MultiThreaded = TRUE;
Internal = FALSE;
LibraryName = 'hellowor';
StartingMethod = (class = Hello, method = Init);
end HelloWorld;
[szerkesztés] Forth
." Hello Vilag!" CR
[szerkesztés] FORTRAN
PROGRAM HELLO
WRITE(*,10)
10 FORMAT('Hello Vilag!')
STOP
END
[szerkesztés] FoxPro/dBase/Clipper
? 'Hello, Vilag!'
[szerkesztés] Frink
println["Hello Vilag!"]
[szerkesztés] Gambas
Lásd még a GUI részt.
PUBLIC SUB Main() Print "Hello Vilag!" END
[szerkesztés] Game Maker
Bizonyos objektumok draw eseményében:
draw_text(x,y,"Hello Vilag");
[szerkesztés] Haskell
module HelloWorld (main) where main = putStr "Hello Vilag\n"
[szerkesztés] Heron
program HelloWorld;
functions {
_main() {
String("Hello Vilag!") |> GetStdOut();
}
}
end
[szerkesztés] HP–41 és HP–42S
(Kézi Hewlett-Packard RPN-alapú alfanumerikus mérnöki számológépek.)
01 LBLTHELLO 02 THELLO, VILAG 03 PROMPT
[szerkesztés] Iptscrae
ON ENTER {
"Hello " "Vilag!" & SAY
}
[szerkesztés] Io
"Hello Vilag!" print
Vagy:
write("Hello Vilag!\n")
[szerkesztés] Java
Lásd még a GUI részt.
public class Hello {
public static void main(String[] args) {
System.out.println("Helló Világ!");
}
}
[szerkesztés] JVM
(Disassemblerkivitel: javap -c Hello.class)
public class Hello extends java.lang.Object {
public Hello();
public static void main(java.lang.String[]);
}
Method Hello()
0 aload_0
1 invokespecial #1 <Method java.lang.Object()>
4 return
Method void main(java.lang.String[])
0 getstatic #2 <Field java.io.PrintStream out>
3 ldc #3 <String "Helló Világ!">
5 invokevirtual #4 <Method void println(java.lang.String)>
8 return
[szerkesztés] Kogut
WriteLine "Hello Vilag!"
[szerkesztés] Logo
print [Hello Vilag!]
vagy
pr [Hello Vilag!]
Csak mswlogóban:
messagebox [Hi] [Hello Vilag]
Csak magyar Comenius Logóban:
kiír [Hello Világ!]
[szerkesztés] Lua
print "Hello Vilag!"
[szerkesztés] M (MUMPS)
W "Hello Vilag!"
vagy
WRITE "Hello Vilag!"
[szerkesztés] Mathematica
Print["Hello Vilag"]
[szerkesztés] Modula-2
MODULE Hello;
FROM Terminal2 IMPORT WriteLn; WriteString;
BEGIN
WriteString("Hello Vilag!");
WriteLn;
END Hello;
[szerkesztés] MS-DOS parancsfájl
A szabványos command.com parancsértelmezővel. A @ jel opcionális, és megakadályozza a rendszert, hogy a parancs végrehajtása előtt magát a parancsot is kiírja. A @ jelet el kell hagyni az 5.0-snál korábbi MS-DOS-verziók esetén.
@echo Helló Világ!
[szerkesztés] MUF
: main me @ "Hello Vilag!" notify ;
[szerkesztés] Objective C
#import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog(@"Hello Vilag!");
[pool release];
return 0;
}
[szerkesztés] OCaml
let _ = print_endline "Hello Vilag!";;
[szerkesztés] OPL
Lásd még a GUI részt.
PROC hello: PRINT "Hello Vilag" ENDP
[szerkesztés] OPS5
(object-class request
^action)
(startup
(strategy MEA)
(make request ^action hello)
)
(rule hello
(request ^action hello)
-->
(write |Hello Vilag!| (crlf))
)
[szerkesztés] Pascal
program Hello;
begin
writeln('Helló Világ!');
end.
[szerkesztés] Perl
print "Hello Vilag!\n";
[szerkesztés] PHP
echo "Helló Világ!";
vagy
print('Helló világ!');
[szerkesztés] Pike
int main() {
write("Hello Vilag!\n");
return 0;
}
[szerkesztés] PL/I
Test: procedure options(main);
declare My_String char(20) varying initialize('Hello Vilag!');
put skip list(My_String);
end Test;
[szerkesztés] POP-11
'Hello Vilag' =>
[szerkesztés] POV-Ray
#include "colors.inc"
camera {
location <3, 1, -10>
look_at <3,0,0>
}
light_source { <500,500,-1000> White }
text {
ttf "timrom.ttf" "Hello Vilag!" 1, 0
pigment { White }
}
[szerkesztés] Prolog
write('Hello Vilag'),nl.
[szerkesztés] Python
print "Hello, Vilag!"
[szerkesztés] REXX, NetRexx és Object REXX
say "Hello Vilag!"
[szerkesztés] RPL
Lásd még a GUI részt.
(A Hewlett-Packard HP–28, HP–48 és HP–49 sorozatú gráfszámológépeken.)
<< CLLCD "Hello Vilag!" 1 DISP 0 WAIT DROP >>
[szerkesztés] Ruby
Lásd még a GUI részt.
puts "Hello Vilag!"
[szerkesztés] SAS
data _null_; put 'Hello Vilag!'; run;
[szerkesztés] Sather
class HELLO_WORLD is main is #OUT+"Hello Vilag\n"; end; end;
[szerkesztés] Scala
object HelloWorld with Application {
Console.println("Hello Vilag!");
}
[szerkesztés] Scheme
(display "Hello Vilag!") (newline)
[szerkesztés] sed
Megjegyzés: Legalább egy sornyi bevitelre szüksége van.
sed -ne '1s/.*/Hello Vilag!/p'
[szerkesztés] Seed7
$ include "seed7_05.s7i";
const proc: main is func
begin
writeln("Hello Vilag!");
end func;
[szerkesztés] Self
'Hello Vilag!!' print.
[szerkesztés] Smalltalk
Transcript show: 'Hello Vilag!'
[szerkesztés] SML
print "Hello Vilag!\n";
[szerkesztés] SNOBOL
OUTPUT = "Hello Vilag!"
END
[szerkesztés] SQL
create table MESSAGE (TEXT char(15));
insert into MESSAGE (TEXT) values ('Helló Világ!');
select TEXT from MESSAGE;
drop table MESSAGE;
Vagy (pl. Oracle-dialektus):
select 'Helló Világ' from dual;
Vagy (pl. MySQL-dialektus):
select 'Helló Világ';
Vagy még egyszerűbben:
print 'Helló Világ!'
Vagy (KB-SQL-dialektus):
select Null from DATA_DICTIONARY.SQL_QUERY FOOTER vagy HEADER vagy DETAIL vagy FINAL esemény write "Helló Világ!"
[szerkesztés] STARLET
RACINE: HELLO_WORLD.
NOTIONS:
HELLO_WORLD : ecrire("Hello Vilag!").
[szerkesztés] TACL
#OUTPUT Hello Vilag!
[szerkesztés] Tcl
puts "Hello Vilag!"
[szerkesztés] Turing
put "Hello Vilag!"
[szerkesztés] TSQL
Declare @Output varchar(16) Set @Output='Helló Világ!' Select @Output
Vagy egyszerűbb variációk:
Select 'Helló Világ!'
Print 'Helló Világ!'
[szerkesztés] UNIX-stílusú rendszerhéj
echo 'Hello Vilag!'
[szerkesztés] Grafikus felhasználói felületek (GUI)
[szerkesztés] ActionScript (Macromedia Flash MX)
trace ("Helló Világ!")
[szerkesztés] AppleScript
display dialog "Helló Világ!"
[szerkesztés] Cocoa vagy GNUstep (Objective C-ben)
#import <Cocoa/Cocoa.h>
@interface hello : NSObject {
}
@end
@implementation hello
-(void)awakeFromNib
{
NSBeep(); // Nem szükséges, de szokás hangjelzést adni figyelmeztetés megjelenítésekor
NSRunAlertPanel(@"Üzenet a számítógéptől", @"Hello Vilag!", @"Hello!", nil, nil);
}
@end
[szerkesztés] Delphi, Kylix
ShowMessage("Hello Vilag!");
[szerkesztés] Gambas
Lásd még a TUI részt.
PUBLIC SUB Main()
Message.Info("Hello Vilag!")
END
[szerkesztés] GTK eszközkészlet (C++-ban)
#include <iostream>
#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>
using namespace std;
class HelloWorld : public Gtk::Window {
public:
HelloWorld();
virtual ~HelloWorld();
protected:
Gtk::Button m_button;
virtual void on_button_clicked();
};
HelloWorld::HelloWorld()
: m_button("Hello Vilag!") {
set_border_width(10);
m_button.signal_clicked().connect(SigC::slot(*this,
&HelloWorld::on_button_clicked));
add(m_button);
m_button.show();
}
HelloWorld::~HelloWorld() {}
void HelloWorld::on_button_clicked() {
cout << "Helló Világ!" << endl;
}
int main (int argc, char *argv[]) {
Gtk::Main kit(argc, argv);
HelloWorld helloworld;
Gtk::Main::run(helloworld);
return 0;
}
[szerkesztés] GTK# (C#-ban)
using Gtk;
using GtkSharp;
using System;
class Hello {
static void Main()
{
Application.Init ();
Window window = new Window ("Helló Világ!");
window.Show();
Application.Run ();
}
}
[szerkesztés] GTK 2.x (Euphoriában)
include gtk2/wrapper.e Info(NULL,"Hello","Hello Vilag!")
[szerkesztés] Java
Lásd még a TUI részt.
import javax.swing.JOptionPane;
public class Hello {
public static void main(String[] args) {
JOptionPane.showMessageDialog(null, "Helló Világ!");
System.exit(0);
}
}
[szerkesztés] Java applet
A Java kisalkalmazások HTML fájlokkal működnek együtt.
<HTML>
<HEAD>
<TITLE>Helló Világ!</TITLE>
</HEAD>
<BODY>
HelloWorld Program says:
<APPLET CODE="HelloWorld.class" WIDTH=600 HEIGHT=100>
</APPLET>
</BODY>
</HTML>
import java.applet.*;
import java.awt.*;
public class HelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString("Helló Világ!", 100, 50);
}
}
[szerkesztés] JavaScript (másnéven ECMAScript) és JScript
A JavaScript egy ügyféloldali parancsleírónyelv, melyet HTML fájlokban használnak. Az alábbi kódot bármely HTML fájlban elhelyezhetjük.
<script type="text/javascript"><!--
function helloWorld()
{
alert("Helló Világ!");
}
//--></script>
<a href="#" onclick="helloWorld()">Helló Világ példa</a>
Egy egyszerűbb módszer implicit módon használja a JavaScriptet, a lefoglalt alert függvényt hívva meg. Az alábbi sort a <BODY> … </BODY> HTML-címkék közé kell helyezni.
<a href="#" onclick="alert('Helló Világ!')">Helló Világ példa</a>
Egy, még ennél is egyszerűbb módszer a népszerű böngészők virtuális „javascript” protokolljának használata, mellyel JavaScript-kódot lehet végrehajtani. Az alábbit internetcímként kell megadni:
javascript:alert('Helló Világ!')
[szerkesztés] OPL
Lásd még a TUI részt.
(A Psion Series 3-as és annál újabb, kompatibilis PDA-kon.)
PROC guihello:
ALERT("Hello Vilag!","","Kilépés")
ENDP
[szerkesztés] Qt eszközkészlet (C++-ban)
#include <qapplication.h>
#include <qpushbutton.h>
#include <qwidget.h>
#include <iostream>
class HelloWorld : public QWidget
{
Q_OBJECT
public:
HelloWorld();
virtual ~HelloWorld();
public slots:
void handleButtonClicked();
QPushButton *mPushButton;
};
HelloWorld::HelloWorld() :
QWidget(),
mPushButton(new QPushButton("Helló Világ!", this))
{
connect(mPushButton, SIGNAL(clicked()), this, SLOT(handleButtonClicked()));
}
HelloWorld::~HelloWorld() {}
void HelloWorld::handleButtonClicked()
{
std::cout << "Helló Világ!" << std::endl;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
HelloWorld helloWorld;
app.setMainWidget(&helloWorld);
helloWorld.show();
return app.exec();
}
[szerkesztés] REALbasic
MsgBox "Hello Vilag!"
[szerkesztés] RPL
Lásd még a TUI részt.
(A Hewlett-Packard HP–48G és HP–49G sorozatú számológépeken.)
<< "Hello Vilag!" MSGBOX >>
[szerkesztés] SWT
import org.eclipse.swt.widgets.*;
public class Main {
public static void main (String [] args) {
Display display = new Display ();
Shell shell = new Shell(display);
shell.open ();
while (!shell.isDisposed ()) {
if (!display.readAndDispatch ()) display.sleep ();
}
display.dispose ();
}
}
[szerkesztés] Visual Basic és VBA
MsgBox "Helló Világ!"
[szerkesztés] Windows API (C-ben)
#include <windows.h>
LRESULT CALLBACK WindowProcedure(HWND, UINT, WPARAM, LPARAM);
char szClassName[] = "MainWnd";
HINSTANCE hInstance;
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
HWND hwnd;
MSG msg;
WNDCLASSEX wincl;
hInstance = hInst;
wincl.cbSize = sizeof(WNDCLASSEX);
wincl.cbClsExtra = 0;
wincl.cbWndExtra = 0;
wincl.style = 0;
wincl.hInstance = hInstance;
wincl.lpszClassName = szClassName;
wincl.lpszMenuName = NULL; //No menu
wincl.lpfnWndProc = WindowProcedure;
wincl.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); //Ablak színe
wincl.hIcon = LoadIcon(NULL, IDI_APPLICATION); //EXE-ikon
wincl.hIconSm = LoadIcon(NULL, IDI_APPLICATION); //Kis programikon
wincl.hCursor = LoadCursor(NULL, IDC_ARROW);


Based on work by