int main(char[][] args)
{
	printf("hello world\n");
	printf("args.length = %d\n", args.length);

	for (int i = 0; i < args.length; i++) {
		printf("args[%d] = '%s'\n", i, (char *)args[i]);
	}
	//	備考:
	//	1.castするには明示的に cast(char*)としたほうがいいという話あり
	//	2.char*へcastしなくとも、printf("%.*s",args[i]);のように
	//	%.*s を用いれば、文字列の長さ or \0に到達するまで表示してくれる

	return 0;
}

int main(char[][] args)
{
	printf("hello world\n");
	printf("args.length = %d\n", args.length);

	//	for eachでまわしてみるべし
	foreach (int i,char s[];args){
		printf("args[%d] = '%s'\n", i,(char *)s);
		//	char [] は 概念的にはC++のstringクラスみたいなもの
		//	よって char* に変換しておかないとここでアクセス違反になる
	}
}

	foreach (char s[];args){
		printf("'%s'\n", (char *)s);
	}

	//	for eachでまわしてみるべし
	foreach (char s[] ; args){
		foreach (char c;s)
			printf("%c",c);
		printf("\n");
	}

	static int a[] = [ 123 , 456 ];

	//	for eachでまわしてみるべし
	foreach (inout int n ; a) n += 10;
	foreach (int n ; a) printf("%d\n",n);

	class Foo
	{
		uint array[2];
		void reverse_apply(void delegate(inout uint) dg)
		{
			for (int i = array.length-1 ; i>=0 ;--i)
				dg(array[i]);
		}
	}

int main(){
	Foo f = new Foo;
	f.reverse_apply(
		//	無名関数のdelegate。これを渡してやる。
		//	C++でfunctorを渡すのに似ている
		delegate int(inout uint n) {
			printf("%d\n",n);
		}
	);
	return 0;
}

	int opApply(int delegate(inout uint) dg)
	{
		int result = 0;
		for (int i = 0; i < array.length; i++)
		{
			result = dg(array[i]);
			if (result)
			break;
		}
		return result;
	}

template foo(T) {
	T add (T x,T y) { return x+y; }
}

//	ならば、
	alias foo!(int) foo_int;
//	と実体化したのちに、
	int n = foo_int.add(3,5);
//	のように呼び出すか、あるいは
	int n = foo!(int).add(3,5);
//	のように呼び出す必要があります。

	template foo(T) { T t; }

	//	に対して、
	foo!(int).t = 10;

	int n = foo!(int).t;
	//　これは2度目の実体化に相当するが、
	//	実体化されたものは上のものと同一であるため、
	//	変数tの実体は唯一であり、nには10が代入される

	switch ( x ) {
		case 1 : ...
		case 2 : ...
	//	x == 3の場合は、実行時エラーに！(default:break;を書く必要がある)
	}

import y4d_timer;
import y4d_draw;

import y4d;

int main(){
	//	y4d_timerで定義されているclass timerにアクセスする
	y4d.timer t1 = new y4d.timer;

	//	y4dをimportしているので、y4dというprefixなしでも修飾できる
	timer t2 = new timer;

	return 0;
}

/*
    このmodule内でclass timerを定義した場合、
    y4dのほうのtimerは隠蔽されます。

    すなわち、y4d.timerと書かなければy4dのtimerクラスには
    アクセス出来なくなります。

    単にtimerと書いた場合は、このmodule内のtimerクラスを
    指すことになります。
*/

	alias y4d yaneSDK4D;

	//	このあとy4dの代わりにyaneSDK4Dと修飾できるようになる
	//	例)
	yaneSDK4D.timer t = new yaneSDK4D.timer;

yaneSDK4D\y4D_timer.d(2): module singleton is in multiply defined
↑この2行目とは、import ytl.singletonと書いてある行。

module y4d_input.input;

module y4D_input.input;
　　　　↑大文字

import std.string;

class someclass {
	char [] getString()	{ return toString("abc"); }
}

import std.string;

class someclass {
	char [] getString()	{ return .toString("abc"); }
	//	あるいは std.string.toString↑
}

	int[] a1 = new int[10];
	//	a1 は、0で初期化されたint配列。すぐに使える。
	//	例)
	//	a1[5] = 100;

	bool[] a2 = new bool[10];
	//	a2は、falseで初期化されたbool配列。すぐに使える。
	//	例)
	//	a2[3] = true;

	class foo { }
	foo[] a3 = new foo[10];
	//	a3は、fooクラスの配列。まだfooのインスタンスまでは代入されていない
	//	また、fooのコンストラクタも呼び出されていない
	//	実際に使うためには、このあとfooをnewしなければならない
	//	例)
	//	foreach(inout f;a2) f = new foo;
	//	すなわち、クラスの配列のnewは、クラスのインスタンスを生成するのではなく
	//	配列(C++風に言うとポインタのvector)を生成する。

	struct foo { int a = 5; }
	foo[] a4 = new foo[10];
	printf("%d\n",a4[3].a); // 5が表示される
	//	a4は、foo構造体の配列。
	//	メンバの初期化も終わっている。
	//	※　structにはコンストラクタもデストラクタも書けません。

	interface foo { }
	foo[] a5 = new foo[10];
	//	interfaceは(扱いとしては)抽象クラスの一種なので、
	//	new自体は出来ないが、interfaceの配列自体はnewできる。

// **************************************************
template total(T){}

template total(int T)
{
	instance total(T-1) m_total;
	enum{ val = T + m_total.val }
}

template total(int T : 1)
{
	enum{ val = 1 }
}

void main()
{
	printf("%d\n", instance total(100).val);
}
// **************************************************

// 出力
5050

void test(int x) { printf("int\n"); }
void test(double x) { printf("double\n"); }

int main(){
	test(3.0);
	return 0;
}

void test(int x) { printf("int\n"); }
void test(real x) { printf("real\n"); }

int main(){
	test(3.0);
	return 0;
}

void test(int x) { printf("int\n"); }
void test(double x) { printf("double\n"); }
void test(real x) { printf("real\n"); }

int main(){
	test(3);	//	int
	test(3.0);	//	double
	return 0;
}

	char [] a = "12345678";
	a = a ~ a;						//	連結。この結果、\0終端ではなくなる
	printf("%.*s\n",a);				//	正しい
	printf("%s\n",cast(char*)a);	//	これだとゴミが表示される
	printf("%s\n",std.string.toStringz(a));	//	正しい

T get() { if (!a) return null; else return a[0]; }

T get() { if (!a) return cast(T)(null); else return a[0]; }

void main()
{
	char[] s;
	func(s);	// false

	s = "aaa";
	func(s);	// true

	s = "";
	func(s);	// true!!

	s.length=0;
	func(s);	// false
}

void func(char[] s)
{
	if( s ) 	printf("true\n");
	else		printf("false\n");
}

	int[] an1 = { 1,2,3 };			//	1.の理由で×
	int[] an2 = [ 1,2,3 ];			//	2.の理由で×
	static int[] an3 = { 1,2,3 };	//	1.の理由で×
	static int[] an4 = [ 1,2,3 ];	//	○
	int[] an5 = an4;				//	○ 3.のタイプ

	char [] as1 = "abc";			//	これは配列ではないので○
	char [][] as2 = ["abc" , "def" , "ghi"];	//	2.の理由で×
	static char [] as3 = "abc";					//	これは配列ではないけど○
	static char [][] as4 = ["abc" , "def" , "ghi"];	//	○
	char [][] as2 = as4;						//	○ 3.のタイプ
	printf("%.*s\n",as2[1]);					//	○ 表示。"def"が表示される
	char [][] as5 = new char[][10];				//	char[] を10個。要するに10個の文字列が入る配列を用意している

interface I { abstract void f(); }
class X : I { void f() { } }

void test() {
	I i = new X;
	X x = cast(X)(i);
	x.f(); // アクセス保護違反に
}

abstract class ab_class {
	void test1();
	void test2();
}

class imp : ab_class {
	void test1() { printf("test1\n"); }
	void test2() { printf("test2\n"); }
}

int main(){
	ab_class a = new imp;
	a.test1();	//	imp.test1が呼び出される
}

	enum { A,B,C }
	//	無名enumはconst intの代わりに使えます。

	enum a { A,B,C }
	//　名前つきenum。
	//	int x = a.B のように名前つきで使います。

	enum keycode : char { LEFT='a', DOWN='z', UP='w', RIGHT='s' }
	enum mathConst : float { PI=3.14, E=2.72, GAMMA=0.58 }

void[] test1(){
	try {
	} catch {
		return null;
		//	このreturn がなければエラーになる
	}
}

void[] test2(int n) {
	if (n == 5){
	} else {
		return null;
		//	このreturn がなければエラーになる
	}
}

	char[] s;
	char[] t = "123";

	while (1) {
		s = t ~ s;
		//	何か処理
	}

	s = t.dup ~ s;

struct foo { int a,b; }

int main(){

foo f1; // スタック上に確保される
f1 = new foo; // ng (コンパイルエラー)
// structのnewは、ポインタ型を返す。
// よってfoo*をfooにキャスト出来ないのでエラー。

foo* f2 = new foo; // ヒープ上に確保するならこれ
foo[] f3 = new foo[5]; // ok。foo[5]はヒープ上に確保される
f3 ~= new foo; // コンパイルエラー。
// structの配列は、D言語的な動的配列(C++のstd::vectorぽいの)
// ではなくC言語的な単純な配列なのでくっつけることは出来ない

foo*[] f4 = new foo; // ok
f4 ~= new foo; // ok
// foo* の(D言語的な)動的配列なのでつっつけることが出来る

foo* f5 = new foo[5]; // ok。foo[5]は、foo[]型を返すが、
// foo[]型はfoo*型へ暗黙でキャストできるのでok

foo[] f6 = new foo; // ng
// foo*型をfoo[]型へ暗黙ではキャストできない
// (配列にはサイズ情報が必要なため)

foo[][] f7 = new foo[][]; // ng
foo[][] f8 = new foo[][10]; // ok
foo[][] f9 = new foo[10][]; // ng

struct Point { int x,y; }
void foo(Point[4]* points){
	(*points)[0].x = 10;	// points[0].x = 10; は不正
}

void	test_function() {
	Point[4] points;
	foo(&points);
}

struct Point { int x,y; }
void foo(Point[4] points){
	points[0].x = 10;
}

void	test_function() {
	Point[4] points;
	foo(points);
}