„Helló, világ!” programpéldák listája
A Wikipédiából, a szabad enciklopédiábó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ás né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 /
326 / V
311 / I
314 / L
300 / A
307 / G
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 ", VIL"
ALF "AG! "
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
BEGIN {print "Hello, vilag!"; exit}
[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:
:HelloVilag() :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_VILAG'
MODULE HELLO_VILAG (IDENT='V1.0', MAIN=HELLO_VILAG,
ADDRESSING_MODE (EXTERNAL=GENERAL)) =
BEGIN
LIBRARY 'SYS$LIBRARY:STARLET';
EXTERNAL ROUTINE
LIB$PUT_OUTPUT;
GLOBAL ROUTINE HELLO_VILAG =
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;
}
[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-VILAG. 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] D (DTrace)
#pragma D option quiet
BEGIN
{
printf("Hello, vilag!\n");
exit(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_VILAG
creation
make
feature
make is
local
io:BASIC_IO
do
!!io
io.put_string("%N Hello, vilag!")
end -- make
end -- class HELLO_VILAG
[szerkesztés] Erlang
-module(hello).
-export([hello_vilag/0]).
hello_vilag() -> 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 HelloVilag;
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 = 'hellovil';
StartingMethod = (class = Hello, method = Init);
end HelloVilag;
[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 HelloVilag (main) where main = putStr "Hello, vilag\n"
[szerkesztés] Heron
program HelloVilag;
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
<?php echo "Helló, világ!"; ?>
vagy
<?php
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
puts "Hello, vilag!"
[szerkesztés] SAS
data _null_; put 'Hello, vilag!'; run;
[szerkesztés] Sather
class HELLO_VILAG is main is #OUT+"Hello, vilag\n"; end; end;
[szerkesztés] Scala
object HelloVilag with Application {
Console.println("Hello, vilag!");
}
[szerkesztés] Scheme
(display "Hello, vilag!") (newline)
[szerkesztés] sed
Megjegyzés: Legalább egysornyi 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_VILAG.
NOTIONS:
HELLO_VILAG : 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", @"Helló, világ!", @"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 HelloVilag : public Gtk::Window {
public:
HelloVilag();
virtual ~HelloVilag();
protected:
Gtk::Button m_button;
virtual void on_button_clicked();
};
HelloVilag::HelloVilag()
: m_button("Hello, vilag!") {
set_border_width(10);
m_button.signal_clicked().connect(SigC::slot(*this,
&HelloVilag::on_button_clicked));
add(m_button);
m_button.show();
}
HelloVilag::~HelloVilag() {}
void HelloVilag::on_button_clicked() {
cout << "Helló, világ!" << endl;
}
int main (int argc, char *argv[]) {
Gtk::Main kit(argc, argv);
HelloVilag hellovilag;
Gtk::Main::run(hellovilag);
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> A HelloVilag program üzeni: <APPLET CODE="HelloVilag.class" WIDTH=600 HEIGHT=100> </APPLET> </BODY> </HTML>
import java.applet.*;
import java.awt.*;
public class HelloVilag extends Applet {
public void paint(Graphics g) {
g.drawString("Helló, világ!", 100, 50);
}
}
[szerkesztés] JavaScript (más né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 helloVilag()
{
alert("Helló, világ!");
}
//--></script>
<a href="#" onclick="helloVilag()">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] Messenger Plus Live Script (JavaSCript alapon; bejelentkezéskor)
function OnEvent_Initialize(MessengerStart)
{
}
function OnEvent_Uninitialize(MessengerExit)
{
}
function OnEvent_Signin (Email) {
if (Email == Messenger.MyEmail) {
Debug.Trace("Hello Világ!");
MsgPlus.DisplayToast("Hello Világ!", "Hello 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> #include <QPushButton> int main(int argc, char *argv[]) { QApplication app(argc, argv); QPushButton hello("Hello world!"); hello.resize(100, 30); hello.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
Ha nincs form csak egy .bas modul a Sub Main eljárás az alapértelmezett belépési pont.
Public Sub Main() MsgBox "Helló, világ!" End Sub
Ha adtunk formot a projekthez, akkor a Load eseményhez rendelhetjük hozzá az Msgbox függvény hívását:
Public Sub Form_Load() MsgBox "Helló, világ!" End Sub
[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);
