szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[:oktatas:programozás:d|< D]]

====== A D programozási nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2011, 2014
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0]]
  * Web: https://szit.hu

===== Bevezetés =====


A D nyelv egy új programozási nyelv, a C és a C++ alapjain. 

Egy programozási nyelv csak akkor használható ha van hozzá fordító. Fordítót az alábbi helyről tölthetünk le: 
  * http://www.digitalmars.com/d/download.html 
De egy Debian GNU/Linux 6.0-án csak adjuk ki a következő parancsot:
  apt-get install gdc



===== Helló Világ =====


<code d Program01.d>
import std.stdio;
void main() {
    writeln("Helló Világ");
}
</code>

Fordítás: 
  gdc -o main main.d

===== Kivitel =====

Kivitelre használható függvények:
  * write()
  * writeln()
  * writef()

A write() függvény sortörés nélkül ír a képernyőre. 
A writeln() függvény a kiírt adatok végén sortörést ír a képernyőre. 
A writef() függvénye nem tesz sortörés karaktert, és formázott kivitelre találták ki.
A formázott kivitelről később lesz szó.

A write() függvénynek több paramétere is lehet:

<code d>
write("Egy", "Kettő","Három");
</code>

A writeln() szintén:

<code d>
writeln("Egy", "Kettő", "Három");
</code>

Mindkét függvény használható paraméter nélkül is.

Írás az alapértelmezett kimenetre:
<code d>
stdout.writeln();
</code>

===== A D nyelv típusai =====
 

|  byte  |  -128 ... 127  |  1 byte  |
|  ubyte |  0 ... 255  |  1 byte  |
|  short  |  -32768  ...  32767  |  2 bytes  |
|  ushort  |  0 ... 65535  |  2 bytes  |
|  int  |  -2147483648 ... 2147483647  |  4 bytes  |
|  uint  |  0  ...  	4294967296  |  4 bytes  |
|  long  |  	-9223372036854775808  ...  9223372036854775807  |  8 bytes  |
|  ulong  |  0  ...  18446744073709551616  |  8 bytes  |
|  float  |  kb.: -3.4E38  ...  kb.: 3.4Ee38  |  4 bytes  |  egy valós szám
|  ifloat  |  kb.: -3.4E38i  ...  kb.: 3.4Ee38i  |  4 bytes  |  egy képzetes szám  |
|  double  |  kb.: -1.8e308  ...  kb.: 1.8e308  |  8 bytes  |  nagy valós szám  |
|  idouble  |  kb.: -1.8e308i  ... kb.: 1.8e308i  |  8 bytes  |  nagy képzetes szám  |
|  real  |  (x86-os gépen) Kb.: -5.9e4436 ... (x86-os gépen) Kb.: 5.9e4436  |  10 bytes  |
|  ireal  |  (x86-os gépen) Kb.: -5.9e4436 ... (x86-os gépen) Kb.: 5.9e4436  |  10 bytes  |  képzetes szám  |
|  char  |  0 ... 255  |  1 byte  |  egy karakter, pl.:  'a'  |
|  wchar  |  0 ... 65535  |  2 bytes |  UTF-16 karakter  |
|  dchar  |  0 ... 4294967296  |  4 bytes  |  UTF-32 karakter  |


===== Változók és állandók a D nyelvben =====

<code d>
int a = 35;
</code>

<code d>
double b = 3.12;
</code>

<code d>
int kor = 27;
writeln("Jóska", kor, "éves" );
</code>

===== Formázott kivitel =====

A formázott kivitel a következő két függvénnyel lehetséges:
  * writef()
  * writefln()

<code d>
int a = 35;
writef("%d", a);
</code>

Pontosság meghatározása:
<code>
double b = 3.1234567;
writef("%.2f\n", b);
</code>

A kiírás szélességének megadása:
<code d>
double b = 3.1234567;
writef("%20f\n", b);
</code>

Vezető nullák megadása:
<code d>
double b = 3.1234567;
writef("%020f\n", b);
</code>

A writefln() metódus létrehozása:
<code d>
double b = 3.1234567;
writefln("%020f", b);
</code>

===== Matematikai függvények =====

A matematikai függvények a std.math névtérben vannak.

Abszolút érték számítás például:
<code d Program01.d>
import std.stdio;
import std.math;
void main(){
	writeln(abs(-5));
}
</code>


<code d Program01.d>
import std.stdio;
import std.math;
void main(){
	double szog = 30;
	writeln(sin(szog * PI / 180));
}
</code>


===== Bevitel =====



<code d>
import std.stdio;
void main()
{
	string s;
	s = readln();
	writefln("Ezt írtad: %s", s);
}
</code>



Szám bevitel

<code d>
import std.stdio, std.conv, std.string;
void main()
{
	writef("Szám: ");
	int a = toInt(chop(readln));
	writefln("Ezt írtad: %d", a);	
}
</code>



<code d>
import std.stdio, std.conv, std.cstream;
void main()
{
	writef("Szám: ");
	int a = toInt(din.readLine());
	writefln("Ezt írtad: %d", a);
}
</code>

===== Szelekció =====

==== Egy ágú ====

<code d>
import std.stdio;
void main()
{
	int a = 3;
	if (a < 4)
		writefln("Kisebb");
	
}
</code>


==== Két ágú ====

<code d>
import std.stdio;
void main()
{
	int a = 3;
	if (a < 4)
		writefln("Kisebb");
	else
		writefln("Nagyobb");
	
}
</code>



==== Több ágú, több utasításos ====

<code d>
import std.stdio;
void main()
{
	int a = 3;
	if (a < 2)
	{
		writefln("Kisebb");
		writefln("a = %d",a);
	}
	else
	{
		writefln("Nagyobb");
		writefln("a = %d", a);
	}
	
}
</code>

==== Több ágú if szelekció ====


<code d>
import std.stdio;
void main()
{
	int a = 0;
	if (a  > 0 )
		writefln("Pozitív");
	else if(a < 0)
		writefln("Negatív");
	else
		writefln("Nulla");
	
}
</code>


===== Iteráció =====

==== for növekményes ciklus ====


<code d Program01.d>
import std.stdio;
void main() {
	for( int i = 0; i< 10; i++)
		writefln(i);
}
</code>

==== Egyszerűen foreach-el ====

<code d>
import std.stdio;
void main()
{
	int[] tomb = [5, 2, 9, 3, 4];
	
	foreach(elem ; tomb)
		writefln(elem);
}
</code>


<code d>
import std.stdio;
void main()
{
	int[] tomb = [5, 2, 9, 3, 4];
	
	foreach(index, elem ; tomb)
		writefln("Index: %d Elem: %d", index, elem);
}
</code>

Visszafele:

<code d>
import std.stdio;
void main()
{
	int[] tomb = [5, 2, 9, 3, 4];
	
	foreach_reverse(index, elem ; tomb)
		writefln("Index: %d Elem: %d", index, elem);
}
</code>


Minden egyes elemet 1-gyel megemelünk
<code d>
import std.stdio;
void main()
{
	int[] tomb = [5, 2, 9, 3, 4];
	
	foreach(ref elem; tomb)
		elem++;
	
	foreach(elem ; tomb)
		writefln(elem);
}
</code>



==== Amíg típusú ciklusok ====


<code d>
while(feltétel)
{
        //ide jön a kód
}
</code>


<code d>
do
{
        //kód
} while(feltétel)
</code>


===== Tömb =====


<code d>
import std.stdio;
void main()
{
	int[] tomb = [1, 2, 3, 4 ];
	
	writefln(tomb[0]);
}
</code>

Az egész tömb kiíratása:
<code d>
import std.stdio;
void main()
{
	int[] tomb = [1, 2, 3, 4 ];
	
	writefln(tomb);
}
</code>

Az eredmény: 
  [1,2,3,4]

===== Karaktersorozatok kezelése =====


Karaktersorozat beolvasása:
<code d Program01.d>
import std.stdio;
void main(){
	char[] nev;
	write("Név: ");
	readln(nev);
	writeln("Ezt írtad: ", nev);
}
</code>

Sorvége jelek bezárása:
<code d Program01.d>
import std.stdio;
import std.string;
void main(){
	char[] nev;
	write("Név: ");
	readln(nev);
	nev = chomp(nev);
	writeln("Ezt írtad: ", nev);
}
</code>

Esetleg így:
<code d Program01.d>
import std.stdio;
import std.string;
void main(){
	write("Név: ");	
	string nev = chomp(readln());
	writeln("Ezt írtad: ", nev);
}
</code>


A szöveg hossza: 
<code d Program01.d>
import std.stdio;
import std.string;
void main(){
	write("Név: ");	
	string nev = chomp(readln());
	writeln("A beírt szöveg hossza: ", nev.length);
}
</code>