„Helló, világ!” programpéldák listája
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üli, ugyanis bizonyos nyelvek, környezetek és eszközök nem képesek az ékezetek megjelenítésére.
Szöveges felhasználói felület
[szerkesztés]Szöveges felhasználói felületekben (TUI; más néven konzolban) használt nyelvek példái.
report Z_HELLO_WORLD.
write 'Hello, világ!'.
WRITE "Hello, vilag!"
with Ada.Text_Io; use Ada.Text_Io;
procedure Hello is
begin
Put_Line ("Helló, világ!");
end Hello;
PROC main()
WriteF('Hello, vilag!')
ENDPROC
9♦8♥J♦A♦2♣3♥7♠J♦A♦7♦J♦J♦A♦3♦J♦5♥6♦4♥J♥A♥6♠6♠J♥A♦7♦J♦A♦9♠4♠J♦A♦3♦J♦A♦9♠2♠J♦A♦6♦J♦A♥3♦2♠J♥
'Hello, vilag!'
IT'S SHOWTIME TALK TO THE HAND "Hello, vilag!" YOU HAVE BEEN TERMINATED
Csak Accumulator architektúra
[szerkesztés]A csak Accumulator architektúrák: DEC PDP–8, PAL–III assembler
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
$
Első sikeres µP/OS-kombinációk
[szerkesztés]Intel 8080/Zilog Z80, CP/M, RMAC assembler
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
Accumulator + indexregisztergép
[szerkesztés]MOS Technology 6502, CBM KERNAL, ca65 assembler
HELLO: LDX #0
LDA MSG,X ; kezdőkarakter betöltése
@LP: JSR $FFD2 ; chrout
INX
LDA MSG,X
BNE @LP
RTS
MSG: .ASCIIZ "Hello, vilag!"
Accumulator/Index mikrokódolt gép
[szerkesztés] ; "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
Bővített accumulator gép
[szerkesztés]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 ; DOS: Kilépés a programból
INT 21H
END
Általános célú fiktív számítógép
[szerkesztés]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
Általános célú CISC regiszter
[szerkesztés]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
CISC irányított többfolyamatos operációs rendszeren
[szerkesztés] .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
RISC processzor
[szerkesztés]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
BEGIN {print "Hello, vilag!"; exit}
echo 'Hello, vilag!'
Casio grafikus számológépeken:
"HELLO, VILAG!"
MS BASIC (hagyományos, strukturálatlan)
[szerkesztés]10 PRINT "Hello, vilag!"
20 END
:Disp "Hello, vilag!"
:HelloVilag()
:Prgm
:Disp "Hello, vilag!"
:EndPrgm
sub main
print "Hello, vilag!"
end sub
Strukturált BASIC
[szerkesztés]print "Hello, vilag!"
end
GET "LIBHDR"
LET START () BE
$(
WRITES ("Hello, vilag!*N")
$)
"!galiv ,olleH">:#,_@
%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
- [----- -- > + <] > - . 'H'
- [- > +++++ <] > ++ . 'e'
+++++ ++ . 'l'
. 'l'
+++ . 'o'
[- > +++++ <] > + . 'vesszo'
----- ----- -- . ' '
-- [- > ++++ <] > -- . 'v'
[----- - > + <] > . 'i'
+++ . 'l'
----- ----- - . 'a'
+++++ + . 'g'
- [--- > + <] > - . '!'
[--- > + <] > - . '\n'
Egy sorban:
-[------->+<]>-.-[->+++++<]>++.+++++++..+++.[->+++++<]>+.------------.--[->++++<]>--.[------>+<]>.+++.-----------.++++++.-[--->+<]>-.[--->+<]>-.
#include <stdio.h>
int main(void)
{
printf("Hello, vilag!\n");
return 0;
}
#include <iostream>
int main()
{
std::cout << "Helló, világ!\n";
}
#BTN A1
#PRI "Hello, vilag!"
#END
.method public static void Main() cil managed
{
.entrypoint
.maxstack 8
ldstr "Hello, vilag!"
call void [mscorlib]System.Console::WriteLine(string)
ret
}
module hello
Start :: String
Start = "Hello, vilag!"
PROC 0
WRITE Hello, vilag!
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-VILAG.
ENVIRONMENT DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.
DISPLAY "Hello, vilag!".
STOP RUN.
(format t "Hello, vilag!~%")
using System;
class Hello
{
static void Main()
{
Console.WriteLine("Helló, világ!");
}
}
import std.stdio;
void main() {
writefln("Helló, világ!");
}
#pragma D option quiet
BEGIN
{
printf("Hello, vilag!\n");
exit(0);
}
DCL parancsfájl
[szerkesztés]$ write sys$output "Hello, vilag!"
ed és ex (ed extended)
[szerkesztés]a Helló, világ! . p
Vagy:
echo -e 'a\nHelló, világ!\n.\np' | ed
echo -e 'a\nHelló, világ!\n.\np' | ex
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
-module(hello).
-export([hello_vilag/0]).
hello_vilag() -> io:fwrite("Hello, vilag!\n").
puts(1, "Hello, vilag!")
printfn "Hello, vilag!"
-TYPE Hello vilag
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;
." Hello, vilag!" CR
PROGRAM HELLO
WRITE(*,10)
10 FORMAT('Hello, vilag!')
STOP
END
? 'Hello, vilag!'
println["Hello, vilag!"]
- Lásd még a GUI részt.
PUBLIC SUB Main()
Print "Hello, vilag!"
END
Bizonyos objektumok draw eseményében:
draw_text(x, y, "Hello, vilag!");
package main
import "fmt"
func main() {
fmt.Println("Helló, világ!")
}
module HelloVilag (main) where
main = putStr "Hello, vilag!\n"
program HelloVilag;
functions {
_main() {
String("Hello, vilag!") |> GetStdOut();
}
}
end
HP–41 és HP–42S
[szerkesztés](Kézi Hewlett-Packard RPN-alapú alfanumerikus mérnöki számológépek.)
01 LBL<sup>T</sup>HELLO 02 <sup>T</sup>HELLO, VILAG 03 PROMPT
ON ENTER {
"Hello " "vilag!" & SAY
}
"Hello, vilag!" print
Vagy:
write("Hello, vilag!\n")
- Lásd még a GUI részt.
public class Hello {
public static void main(String[] args) {
System.out.println("Helló, világ!");
}
}
(Disassembler kivitele: 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
WriteLine "Hello, vilag!"
A különféle Logo implementációk általában támogatják az alábbi utasításokat:
print [Hello, vilag!]
pr [Hello, vilag!]
messagebox [Hi] [Hello, vilag!]
kiír [Helló, világ!]
HAI 1.2
CAN HAS STDIO?
VISIBLE "HELLO, VILAG!!!4!"
KTHXBYE
print "Hello, vilag!"
vagy
print ("Hello, vilag!")
W "Hello, vilag!"
vagy
WRITE "Hello, vilag!"
D'`_^]\JI;X9EUUSuu2rrML-&mH#GF&gU#@.bPv;)(rwpunm
3kSinmlkdib(IHdc\"!Y^]\[ZYXQu8NSLpJINGFjJI+*F?cC
B$@98=<;4Xy76543,Pq).'&%$Hih~}${Ayx}vut:xwvXnm3~
Print["Hello, vilag"]
disp('Hello, vilag!');
MODULE Hello;
FROM Terminal2 IMPORT WriteLn; WriteString;
BEGIN
WriteString("Hello, vilag!");
WriteLn;
END Hello;
MS-DOS parancsfájl
[szerkesztés]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!
: main me @ "Hello, vilag!" notify ;
#import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog(@"Hello, vilag!");
[pool release];
return 0;
}
print_endline "Hello, vilag!";;
- Lásd még a GUI részt.
PROC hello: PRINT "Hello, vilag" ENDP
- Lásd még: Lisp-nyelvjárások.
(object-class request
^action)
(startup
(strategy MEA)
(make request ^action hello)
)
(rule hello
(request ^action hello)
-->
(write |Hello, vilag!| (crlf))
)
program Hello;
begin
WriteLn('Helló, világ!');
end.
print "Hello, vilag!\n";
<?php
echo "Helló, világ!";
?>
vagy
<?php
print('Helló, világ!');
?>
vagy (ha be van állítva a short_open_tag = On, ami alapértelmezetként ki van kapcsolva)
<?='Helló, világ!'?>
int main() {
write("Hello, vilag!\n");
return 0;
}
Test: procedure options(main);
declare My_String char(20) varying initialize('Hello, vilag!');
put skip list(My_String);
end Test;
'Hello, vilag!' =>
%!
/Courier findfont
12 scalefont setfont
newpath
100 100 moveto
(Hello, vilag!) show
showpage
#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 }
}
Write-Host 'Helló, világ!'
write('Hello, vilag!'),nl.
print "Hello, vilag!"
Python 3.0-tól a print nem utasítás, hanem függvény, tehát:
print("Hello, vilag!")
cat("Hello, vilag!\n")
say "Hello, vilag!"
- 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 >>
puts "Helló, világ!"
fn main() {
println!("Helló, világ!");
}
data _null_;
put 'Hello, vilag!';
run;
class HELLO_VILAG is main is #OUT+"Hello, vilag\n"; end; end;
object HelloVilag with Application {
Console.println("Hello, vilag!");
}
(display "Helló, világ!")
(newline)
Megjegyzés: Legalább egysornyi bevitelre szüksége van.
sed -ne '1s/.*/Hello, vilag!/p'
$ include "seed7_05.s7i";
const proc: main is func
begin
writeln("Hello, vilag!");
end func;
'Hello, vilag!!' print.
Transcript show: 'Hello, vilag!'
print "Hello, vilag!\n";
OUTPUT = "Hello, vilag!"
END
Szabványos SQL
[szerkesztés]CREATE TABLE Message (text char(15));
INSERT INTO Message (text) values ('Helló, világ!');
SELECT text FROM Message;
DROP TABLE Message;
SELECT 'Helló, világ!' FROM dual;
SELECT 'Helló, világ!';
Vagy még egyszerűbben:
PRINT 'Helló, világ!'
KB-SQL-dialektus
[szerkesztés]SELECT Null from data_dictionary.sql_query
FOOTER -- vagy HEADER vagy DETAIL vagy FINAL esemény
WRITE "Helló, világ!"
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!'
RACINE: HELLO_VILAG.
NOTIONS:
HELLO_VILAG : ecrire("Hello, vilag!").
#OUTPUT Hello vilag!
puts "Hello, vilag!"
put "Hello, vilag!"
`r`````````````.H.e.l.l.o.,. .v.i.l.a.g.!i
Jelmagyarázat:
A betűk megelőzik a jelzett karaktert, és a nyelv sajátosságainak megfelelően elhagyhatók. (A kód másolása esetén legyünk figyelemmel arra, hogy a #10-es ASCII-kódú soremelés karakter vágólapra helyezésnél böngészőtől és operációs rendszertől függően könnyedén átalakulhat CR-ré (#13), a kód pedig úgy működésképtelenné válik.)
S S S T S S T S S S L T L S S S S S T T S S T S T L T L S S S S S T T S T T S S L T L S S S S S T T S T T S S L T L S S S S S T T S T T T T L T L S S S S S T S T T S S L T L S S S S S T S S S S S L T L S S S S S T S T S T T S L T L S S S S S T T S T S S T L T L S S S S S T T S T T S S L T L S S S S S T T S S S S T L T L S S S S S T T S S T T T L T L S S S S S T S S S S T L T L S S L L L
const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
try stdout.print("Hello, {s}!\n", .{"world"});
}
Grafikus felhasználói felületek (GUI)
[szerkesztés]ActionScript (Adobe Flash CS6)
[szerkesztés]trace("Helló, világ!")
display dialog "Helló, világ!"
Cocoa vagy GNUstep (Objective C-ben)
[szerkesztés]#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
program HelloWorld;
uses
Dialogs;
begin
ShowMessage('Hello, vilag!');
end;
- Lásd még a TUI részt.
PUBLIC SUB Main()
Message.Info("Hello, vilag!")
END
GTK (C++-ban)
[szerkesztés]#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;
}
GTK# (C#-ban)
[szerkesztés]using Gtk;
using GtkSharp;
using System;
class Hello
{
static void Main()
{
Application.Init();
Window window = new Window("Helló, világ!");
window.Show();
Application.Run();
}
}
GTK 2.x (Euphoriában)
[szerkesztés]include gtk2/wrapper.e Info(NULL,"Hello","Hello, vilag!")
- 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);
}
}
Java-applet
[szerkesztés]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);
}
}
A JavaScript egy kliensoldali 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!')
Messenger Plus Live Script (JavaScript alapon, bejelentkezéskor)
[szerkesztés]function OnEvent_Initialize(MessengerStart) {
}
function OnEvent_Uninitialize(MessengerExit) {
}
function OnEvent_Signin (Email) {
if (Email == Messenger.MyEmail) {
Debug.Trace("Helló, világ!");
MsgPlus.DisplayToast("Helló, világ!", "Helló, világ!");
}
}
Lásd még a TUI részt.
(Az OPL nyelvet támogató EPOC és Symbian operációs rendszert futtató gépeken.)
PROC guihello:
ALERT("Hello, vilag!","","Kilépés")
ENDP
Qt eszközkészlet (C++-ban)
[szerkesztés]#include <QApplication>
#include <QPushButton>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QPushButton hello("Hello, vilag!");
hello.resize(100, 30);
hello.show();
return app.exec();
}
MsgBox "Hello, vilag!"
- Lásd még a TUI részt.
A Hewlett-Packard HP–48G és HP–49G sorozatú számológépeken.
<< "Hello, vilag!" MSGBOX >>
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();
}
}
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 például 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
Windows API (C-ben)
[szerkesztés]#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); // Kurzor
if (!RegisterClassEx(&wincl))
return 0;
hwnd = CreateWindowEx(0, // Nincs kiterjesztett ablakstílus
szClassName, // Osztálynév
"", // Ablakcím
WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX,
CW_USEDEFAULT, CW_USEDEFAULT, // A Windows döntse el az ablak bal és felső pozícióit
120, 50, // Ablak szélessége és magassága
NULL, NULL, hInstance, NULL);
//Az ablak látható legyen a képernyőn
ShowWindow(hwnd, nCmdShow);
//Üzenethurok futtatása
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_PAINT:
hdc = BeginPaint(hwnd, &ps);
TextOut(hdc, 15, 3, "Helló, világ!", 13);
EndPaint(hwnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, message, wParam, lParam);
}
return 0;
}
Vagy sokkal egyszerűbben:
#include <windows.h>
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
MessageBox(NULL, "Helló, világ!", "", MB_OK);
return 0;
}
Vizuális nyelvek
[szerkesztés]
