„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
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
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 $
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
Accumulator + indexregisztergép
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
; "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
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
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
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
.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
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)
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
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
$ write sys$output "Hello, vilag!"
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
(Kézi Hewlett-Packard RPN-alapú alfanumerikus mérnöki számológépek.)
01 LBLTHELLO 02 THELLO, 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!");
}
}
(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
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!"
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
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
(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!');
ReadLn;
end.
print "Hello, vilag!\n";
<?php
echo "Helló, világ!";
?>
vagy
<?php
print('Helló, világ!');
?>
vagy (ez csak akkor működik, ha a php-ban be van kapcsolva 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")
REXX, NetRexx és Object REXX
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
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
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:
- S: szóköz (Space)
- T: tabulátor (Tab)
- L: soremelés (Line feed)
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 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éptelen 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
Grafikus felhasználói felületek (GUI)
ActionScript (Adobe Flash CS6)
trace("Helló, világ!")
display dialog "Helló, világ!"
#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 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;
}
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();
}
}
GTK 2.x (Euphoriában)
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);
}
}
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);
}
}
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!')
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("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)
#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();
}
}
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 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)
#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;
}