ソフトウェア概論A/B (2013/05/31)
Ver. 1.0

目次

講義資料

当日の OHP 資料

当日のOHP資料です。

• 表示用(HTML)
• 印刷用(PDF)

Download

• 20130531-update.zip

• 訂正: mingwenv.mfをダウンロードして、c:\usr\c\libに保存してください。

講義で利用するサンプルプログラム

サンプルファイル

• 20130531.zip

Download : sample-001.c ( SJIS 版 )

/*
 * DATE sample-001.c
 */

#include <stdio.h>
#include <string.h>		/* strcmp に必要 */
#include "s_turtle.h"	/* 亀プログラムの場合に必要 */

/*
 * 亀プログラム
 */

/*
 * void jump_n ( char *n )
 *		char *n		足跡の長さを表す
 *			指定された長さだけ現在向いている方向に足跡を残こさず跳ねる
 */

void jump_n ( char *n ) {

	if ( !strcmp ( n, "" ) ) {
		/* n が空文字列 ("") なら何もしない */
	} else {
		s_turtle_jump();	/* とりあえず、一歩跳ねる */
		jump_n ( n + 1 );	/* 文字列を短くして、再帰呼出し */
	}
}	

/*
 *	void move_n ( char *n )
 *
 *		char *n		足跡の長さを表す
 *			指定された長さだけ現在向いている方向に足跡を残して歩く
 */

void move_n ( char *n ) {

	if ( !strcmp ( n, "" ) ) {
		/* n が空文字列 ("") なら何もしない */
	} else {
		s_turtle_move();	/* とりあえず、一歩歩く */
		move_n ( n + 1 );	/* 文字列を短くして、再帰呼出し */
	}
}

/*
 *	void turn_n ( char *n )
 *
 *		現在向いている方向から時計回りに n * 45 度向きを変える
 */

void turn_n ( char *n ) {

	if ( !strcmp ( n, "" ) ) {
		/* n が空文字列 ("") なら何もしない */
	} else {
		s_turtle_turn();	/* とりあえず、45 度向きをかえる */
		turn_n ( n + 1 );	/* 文字列を短くして、再帰呼出し */
	}

}

/*
 *	void turn_90 ( void )
 *
 *		現在向いている方向から時計回りに 90 度向きを
 *			進行方向の「右」に向きを変える
 */

void turn_90 ( void ) {

	turn_n ( "12" );
}

/*
 *	void turn_180 ( void )
 *
 *		現在向いている方向から時計回りに 180 度向きを
 *			進行方向の「後ろ」に向きを変える
 */

void turn_180(void) {

	turn_n ( "1234" );
}

/*
 *	void turn_270 ( void )
 *
 *		現在向いている方向から時計回りに 270 度向きを
 *			進行方向の「左」に向きを変える
 */

void turn_270 ( void ) {

	turn_n ( "123456" );
}

/*
 *	void move_n_and_turn ( char *n )
 *
 *		現在向いている方向から n 歩進んで右を向く
 *			四角形の一辺を書く
 */

void move_n_and_turn ( char *n ) {

	 move_n ( n );

	/* 向きを変える */

	turn_90();
}

/*
 *	void draw_n_sqare( char *n );
 *
 *		一辺が n の長さの四角形を書く
 */

void draw_n_sqare( char *n ) {

	 /* 「長さ n の辺を書いて右を向く」という事を 4 回繰り返す */

	move_n_and_turn(n);
	move_n_and_turn(n);
	move_n_and_turn(n);
	move_n_and_turn(n);
}

/*
 * main
 */

int main ( void ) {

	/*
	 * 最初は真中 (0,0) で上を向いている
	 */

	draw_n_sqare ( "12345678901234567890" ); /* 長さ 20 の矩形を書く */

	turn_270();
	jump_n ( "1234" );	/* 四歩ジャンプする */

	draw_n_sqare ( "12345678901234567890" ); /* 長さ 20 の矩形を書く */

	turn_270();
	jump_n ( "1234" );	/* 四歩ジャンプする */

	draw_n_sqare ( "12345678901234567890" ); /* 長さ 20 の矩形を書く */

	turn_270();
	jump_n ( "1234" );	/* 四歩ジャンプする */

	draw_n_sqare ( "12345678901234567890" ); /* 長さ 20 の矩形を書く */

	/* 次の二行は失くてもよいが.. *.

	turn_270();
	jump_n ( "1234" );	/* 四歩ジャンプする */

	return 0;
}

C:\usr\c>sample-001
C:\usr\c> 

Download : sample-002.c ( SJIS 版 )

/*
 * 2013/05/31 sample-002.c
 */

/*
 * 文字「a」を出力する
 */

#include <stdio.h>

void main ( void ) {

	putchar ( 'a' );	/* 「a」という「文字」を画面に出力 */

}

C:\usr\c>sample-002
aC:\usr\c> 

Download : sample-003.c ( SJIS 版 )

/*
 * 2013/05/31 sample-003.c
 */

/*
 * エスケープコード (「\」)の利用
 */

#include <stdio.h>

void main ( void ) {

	 printf ( "「\\」 を出すには 「'\\\\'」とする ==> " );
	 putchar ( '\\' );
	 printf ( "\n" );

	 printf ( "「'」を出すには 「'\\''」とする ==> " );
	 putchar ( '\'' );
	 printf ( "\n" );

	 printf ( "「ビープ音」を出すには 「'\\a'」とする ==> " );
	 putchar ( '\a' );			/* ここで文字は表示されず、音が出る */
	 printf ( "\n" );

	 printf ( "「\"」を出すには 「'\"'」だけでよい ==> " );
	 putchar ( '"' );
	 printf ( "\n" );

}

C:\usr\c>sample-003
「\」 を出すには 「'\\'」とする ==> \
「'」を出すには 「'\''」とする ==> '
「ビープ音」を出すには 「'\a'」とする ==> ^G
「"」を出すには 「'"'」だけでよい ==> "
C:\usr\c> 

Download : sample-004.c ( SJIS 版 )

/*
 * 2013/05/31 sample-004.c
 */

/*
 * 文字列
 */

#include <stdio.h>

void main ( void ) {

	printf ( "文字列\n" );	/* 「文字列」+「改行」が表示される */

}

C:\usr\c>sample-004
文字列
C:\usr\c> 

Download : sample-005.c ( SJIS 版 )

/*
 * 2013/05/31 sample-005.c
 */

/*
 * 文字列の中のエスケープコード
 */

#include <stdio.h>

void main ( void ) {

	printf ( "エスケープコード(「\\」)の扱いは、基本文字と同じ\n" );
	printf ( "「\\」と出力したければ、「\\\\」とかけばよい\n" );
	printf ( "文字では「'」を出すのに「\\'」としたが文字列では「'」で良い\n" );
	printf ( "その代わりに文字列では「\"」を出すのには「\\\"」する必要がある\n" );

}

C:\usr\c>sample-005
エスケープコード(「\」)の扱いは、基本文字と同じ
「\」と出力したければ、「\\」とかけばよい
文字では「'」を出すのに「\'」としたが文字列では「'」で良い
その代わりに文字列では「"」を出すのには「\"」する必要がある
C:\usr\c> 

Download : sample-006.c ( SJIS 版 )

/*
 * 2013/05/31 sample-006.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 *	void do_turtle ( char *program )
 *		char *program -- 亀命令列
 */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == 'm' ) { /* move 命令 !! */
		s_turtle_move();
	} else if ( *program == 'j' ) { /* jump 命令 !! */
		s_turtle_jump();
	} else if ( *program == 't' ) { /* turn 命令 !! */
		s_turtle_turn();
	} else {				/* その他 */
		/* 何だか解らないので無視する */
	}

	/*
	 * 残りの処理
	 */

	do_turtle ( program + 1 );	/* 再帰呼び出し */

  }
}



/*
 *
 */

int main ( void ) {

  do_turtle ( "mmmmmmttmmmmmmttmmmmmmttmmmmmmtt" ); /* 四角を書く */

do_turtle ( "mmmmmmmmmmmmttmmmmmmmmmmmmttmmmmmmmmmmmmttmmmmmmmmmmmmtt" ); \
    /* 四角を書く */

  return 0;
}

C:\usr\c>sample-006
C:\usr\c> 

Download : sample-007.c ( SJIS 版 )

/*
 * 2013/05/31 sample-007.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}




/*
 *
 */

int main ( void ) {

  do_turtle ( "6m2t6m2t6m2t6m2t" ); /* 四角を書く */

  do_turtle ( "6m6m2t6m6m2t6m6m2t6m6m2t" ); /* 四角を書く */

  return 0;
}

C:\usr\c>sample-007
C:\usr\c> 

Download : sample-008.c ( SJIS 版 )

/*
 * 2013/05/31 sample-008.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * void triangl_n ( char *length )
 *	char *length -- 辺の長さ
 *		指定した長さの辺を持つ三角形を書く
 */

void triangl_n ( char *length ) {

		/* / */
	do_turtle ( "t" );
	do_n_turtle ( "m", length );

		/* \ */
	do_turtle ( "2t" );
	do_n_turtle ( "m", length );

		/* _ */
	do_turtle ( "3t" );
	do_n_turtle ( "m", length );
	do_n_turtle ( "m", length );

		/**/
	do_turtle ( "2t" );

}



/*
 *
 */

int main ( void ) {

	triangl_n ( "123456" );			/* 三角を書く */
	triangl_n ( "123456789012" );	/* 三角を書く */

  return 0;
}

C:\usr\c>sample-008
C:\usr\c> 

Download : sample-009.c ( SJIS 版 )

/*
 * 2013/05/31 sample-009.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * void triangl_n ( char *length )
 *	char *length -- 辺の長さ
 *		指定した長さの辺を持つ三角形を書く
 */

void triangl_n ( char *length ) {

		/* / */
	do_turtle ( "t" );
	do_n_turtle ( "m", length );

		/* \ */
	do_turtle ( "2t" );
	do_n_turtle ( "m", length );

		/* _ */
	do_turtle ( "3t" );
	do_n_turtle ( "m", length );
	do_n_turtle ( "m", length );

		/**/
	do_turtle ( "2t" );

}



/*
 *
 */

void pinwheel_sub ( char *length, char *times ) {

	 if ( *times == EOS ) {
	 } else {
			/* 羽の柄 */
		do_n_turtle ( "m", "**" );

			/* 羽の柄 */
		triangl_n ( length );

			/* 元の位置に戻る */
		do_turtle ( "4t" );
		do_n_turtle ( "j", "**" );
		do_turtle ( "4t" );

			/* 向きをかえる */
		do_turtle ( "2t" );

		pinwheel_sub ( length, times + 1 );
	 }

}

	/* 風車 */
void pinwheel ( char *length ) {

	pinwheel_sub ( length, "****" );	/* 4 回羽をかけば.. */

}

/*
 *
 */

int main ( void ) {

	pinwheel ( "********" );

  return 0;
}

C:\usr\c>sample-009
C:\usr\c> 

Download : sample-010.c ( SJIS 版 )

/*
 * 2013/05/31 sample-010.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * do_n_m_turtle ( char *program, char *n, char *m )
 *		*program の先頭を n の長さと m の長さの積だけ繰り返す
 */

void do_n_m_turtle ( char *program, char *n, char *m ) {

	if ( *m == EOS ) {
	} else {
		do_n_turtle ( program, n );
		do_n_m_turtle ( program, n, m + 1 );
	}
}



/*
 * oct_sub ( char *length, char *times )
 *	八角形の length の長さと同じ長さ辺を times の長さ回だけ表示する
 */

void oct_sub ( char *length, char *times ) {

	 if ( *times == EOS ) {
	 } else {
		do_n_m_turtle ( "m", length, "**" );
		do_turtle ( "t" );

		oct_sub ( length, times + 1 );
	 }

}

	/* 八角形 */

void oct ( char *length ) {

	do_turtle ( "t" );
	do_n_turtle ( "j", length );
	do_turtle ( "7t" );
	do_n_m_turtle ( "j", length, "**" );
	do_turtle ( "3t" );

	oct_sub ( length, "********" );

	do_turtle ( "t" );
	do_n_m_turtle ( "j", length, "**" );
	do_turtle ( "t" );
	do_n_turtle ( "j", length );
	do_turtle ( "3t" );

}

/*
 *
 */

int main ( void ) {

	oct ( "********" );

	oct ( "****************" );

  return 0;
}

C:\usr\c>sample-010
C:\usr\c> 

Download : sample-011.c ( SJIS 版 )

/*
 * 2013/05/31 sample-011.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * do_n_m_turtle ( char *program, char *n, char *m )
 *		*program の先頭を n の長さと m の長さの積だけ繰り返す
 */

void do_n_m_turtle ( char *program, char *n, char *m ) {

	if ( *m == EOS ) {
	} else {
		do_n_turtle ( program, n );
		do_n_m_turtle ( program, n, m + 1 );
	}
}


/*
 *	do_2power_turtle ( char *program, char *power )
 *		program の先頭の命令を 2 の power の長さのべき乗回だけ実行する
 */

void do_2power_turtle ( char *program, char *power ) {

	if ( *power == EOS ) {				/* 2^0 = 1 なので.. */
		do_n_turtle ( program, "*" );	/* 1 回だけ行う */
	} else {				   			/* 2^{n+1} = 2 * 2^n = 2^n + 2^n */
		do_2power_turtle ( program, power + 1 );
		do_2power_turtle ( program, power + 1 );
	}
}


/*
 *
 */

int main ( void ) {

	do_turtle ( "2t" );
	do_2power_turtle ( "m", "****" );
	do_turtle ( "2t" );
	do_2power_turtle ( "m", "****" );

	do_turtle ( "6t" );
	do_2power_turtle ( "m", "***" );
	do_turtle ( "6t" );
	do_2power_turtle ( "m", "***" );

	do_turtle ( "2t" );
	do_2power_turtle ( "m", "**" );
	do_turtle ( "2t" );
	do_2power_turtle ( "m", "**" );

	do_turtle ( "6t" );
	do_2power_turtle ( "m", "*" );
	do_turtle ( "6t" );
	do_2power_turtle ( "m", "*" );

	return 0;
}

C:\usr\c>sample-011
C:\usr\c> 

Download : sample-012.c ( SJIS 版 )

/*
 * 2013/05/31 sample-012.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * do_n_m_turtle ( char *program, char *n, char *m )
 *		*program の先頭を n の長さと m の長さの積だけ繰り返す
 */

void do_n_m_turtle ( char *program, char *n, char *m ) {

	if ( *m == EOS ) {
	} else {
		do_n_turtle ( program, n );
		do_n_m_turtle ( program, n, m + 1 );
	}
}


/*
 *	do_2power_turtle ( char *program, char *power )
 *		program の先頭の命令を 2 の power の長さのべき乗回だけ実行する
 */

void do_2power_turtle ( char *program, char *power ) {

	if ( *power == EOS ) {				/* 2^0 = 1 なので.. */
		do_n_turtle ( program, "*" );	/* 1 回だけ行う */
	} else {				   			/* 2^{n+1} = 2 * 2^n = 2^n + 2^n */
		do_2power_turtle ( program, power + 1 );
		do_2power_turtle ( program, power + 1 );
	}
}


/*
 *	rec_figure ( char *length )
 *		length の長さだけの深さをもつ再帰的な図形
 */

void rec_figure ( char *length ) {

	if ( *length == EOS ) {
	} else {
		do_2power_turtle ( "m", length );
		do_turtle ( "2t" );
		rec_figure ( length + 1 );
		do_turtle ( "2t" );
		rec_figure ( length + 1 );
		do_turtle ( "2t" );
		rec_figure ( length + 1 );
		do_turtle ( "6t" );
		do_2power_turtle ( "j", length );
		do_turtle ( "4t" );
	}

}

/*
 *
 */

int main ( void ) {

	do_turtle ( "4t" );
	do_2power_turtle ( "j", "******" );
	do_turtle ( "4t" );

	rec_figure ( "******" );

	return 0;
}

C:\usr\c>sample-012
C:\usr\c> 

Download : sample-013.c ( SJIS 版 )

/*
 * 2013/05/31 sample-013.c
 */

#include <stdio.h>
#include <string.h>
#include "s_turtle.h"


/*
 *
 */

#define	EOS	'\0'


/*
 * 亀プログラム
 *
 */

 /*
  *	void do_1_turtle ( char *program )
  *		char *program -- 亀のプログラム ( 先頭の文字しか見ない .. )
  *			文字列の先頭により何をするか考え、それだけを実行する
  */

void do_1_turtle ( char *program ) {

  if ( *program == EOS ) {
	/* 何もしない */
  } else if ( *program == 'm' ) { /* move 命令 !! */
	s_turtle_move();
  } else if ( *program == 'j' ) { /* jump 命令 !! */
	s_turtle_jump();
  } else if ( *program == 't' ) { /* turn 命令 !! */
	s_turtle_turn();
  } else {				/* その他 */
	/* 何だか解らないので無視する */
  }
}

 /*
  * void do_n_turtle ( char *program, char *length )
  *		char *program -- 亀プログラム ( 先頭しか見ない.. )
  *		char *length  -- 命令を繰り返す回数を表す
  *			文字列の先頭を指定した長さだけ繰り返す
  */

void do_n_turtle ( char *program, char *length ) {

  if ( *length == EOS ) {
	/* なにもしない */
  } else {
	do_1_turtle ( program );				/* とりあえず「一回」やる */
	do_n_turtle ( program, length + 1 );	/* 「残り」をやる (再帰呼び出し) */
  }
}

 /*
  * void do_turtle ( char *program ) {
  *		char *program -- 数字を含む亀プログラム
  *			文字列の先頭が数字の場合、次の命令をその数字の表す数だけ繰り返す
  */

void do_turtle ( char *program ) {

  if ( *program == EOS ) {		/* 空文字列なら */
								/* なにもしない (終了) */
  } else {

	/*
	 * 一文字分の処理 : program の先頭の文字によって挙動をかえる
	 */

	if ( *program == '2' ) {				/* 「数字」の処理 */
		do_n_turtle ( program + 1, "12" );	/* 「次」を繰り返す */
		do_turtle ( program + 2 );			/* 「残り(次の次)」をやる (再帰) */
	} else if ( *program == '3' ) {
		do_n_turtle ( program + 1, "123" );
		do_turtle ( program + 2 );
	} else if ( *program == '4' ) {
		do_n_turtle ( program + 1, "1234" );
		do_turtle ( program + 2 );
	} else if ( *program == '5' ) {
		do_n_turtle ( program + 1, "12345" );
		do_turtle ( program + 2 );
	} else if ( *program == '6' ) {
		do_n_turtle ( program + 1, "123456" );
		do_turtle ( program + 2 );
	} else if ( *program == '7' ) {
		do_n_turtle ( program + 1, "1234567" );
		do_turtle ( program + 2 );
	} else if ( *program == '8' ) {
		do_n_turtle ( program + 1, "12345678" );
		do_turtle ( program + 2 );
	} else if ( *program == '9' ) {
		do_n_turtle ( program + 1, "123456789" );
		do_turtle ( program + 2 );
	} else {						/* まだ、する事がある */
		do_1_turtle ( program );	/* とりあえず「先頭」のみを一度やる */
		do_turtle ( program + 1 );	/* 「残り」をやる (再帰) */
  	}
  }
}



/*
 * do_n_m_turtle ( char *program, char *n, char *m )
 *		*program の先頭を n の長さと m の長さの積だけ繰り返す
 */

void do_n_m_turtle ( char *program, char *n, char *m ) {

	if ( *m == EOS ) {
	} else {
		do_n_turtle ( program, n );
		do_n_m_turtle ( program, n, m + 1 );
	}
}


/*
 *	do_2power_turtle ( char *program, char *power )
 *		program の先頭の命令を 2 の power の長さのべき乗回だけ実行する
 */

void do_2power_turtle ( char *program, char *power ) {

	if ( *power == EOS ) {				/* 2^0 = 1 なので.. */
		do_n_turtle ( program, "*" );	/* 1 回だけ行う */
	} else {				   			/* 2^{n+1} = 2 * 2^n = 2^n + 2^n */
		do_2power_turtle ( program, power + 1 );
		do_2power_turtle ( program, power + 1 );
	}
}


/*
 *	koch ( char *dim, char *length )
 *		char *dim -- 次元
 *		char *length -- 辺の長さ
 *			コッホ曲線 (Koch curve) を書く 
 */

void koch ( char *deep, char *length ) {

	if ( *deep == EOS ) {
		do_n_turtle ( "m", length );
	} else {
		koch ( deep + 1, length );
		do_n_turtle ( "t", "1" );
		koch ( deep + 1, length );
		do_n_turtle ( "t", "123456" );
		koch ( deep + 1, length );
		do_n_turtle ( "t", "1" );
		koch ( deep + 1, length );
	}

}

/*
 *
 */

int main ( void ) {

	do_2power_turtle ( "j", "123456" );
	do_turtle ( "4t" );

	koch ( "123", "12" );

	return 0;
}

C:\usr\c>sample-013
C:\usr\c> 

Download : sample-014.c ( SJIS 版 )

/*
 * 2013/05/31 sample-014.c
 */

#include <stdio.h>

/*
 * main
 */

int main(void) {

	putchar ( getchar() );	/* getchar() で文字を読込み、それを出力 */
	putchar ( '\n' );		/* 改行の出力 */

	return 0;
}

a

C:\usr\c>sample-014<  sample-014.in
aa
C:\usr\c> 

Download : sample-015.c ( SJIS 版 )

/*
 * 2013/05/31 sample-015.c
 */

#include <stdio.h>

/*
 * echo_char ( char ch )
 *	char ch	--	引数で指定された文字
 *		引数で指定された文字を『』付で出力
 */

void echo_char ( char ch )	{
	 printf ( "『" );
	 putchar ( ch );		/* 引数で指定された文字を出力する */
	 printf ( "』" );
}

/*
 * main
 */

int main(void) {

	echo_char ( getchar() );	/* getchar() で文字を読込み、それを出力 */
	putchar ( '\n' );

	return 0;
}

a

C:\usr\c>sample-015<  sample-015.in
a『a』
C:\usr\c> 

Download : sample-016.c ( SJIS 版 )

/*
 * 2013/05/31 sample-016.c
 */

#include <stdio.h>

/*
 * check_star_char
 */

void check_star_char ( char ch ) {

	if ( ch == '*' ) {		/* ch の中身が '*' かどうかをチェック */
	 	printf ( "これは「＊」です\n" );
	} else {
	 	printf ( "これは「＊」ではありません\n" );
	}

}

/*
 * main
 */

int main(void) {

	check_star_char ( getchar() );	/* getchar() で文字を読込み、それを出力 */

	return 0;
}

*

C:\usr\c>sample-016<  sample-016.in
*これは「＊」です
C:\usr\c> 

Download : sample-017.c ( SJIS 版 )

/*
 * 2013/05/31 sample-017.c
 */

#include <stdio.h>

/*
 * 改行までを読み込む
 */

void check_star_char ( char ch ) {

	if ( ch == '*' ) {		/* ch の中身が '*' かどうかをチェック */
	 	printf ( "これは「＊」です\n" );
	} else {
	 	printf ( "これは「＊」ではありません\n" );
	}

}

/*
 * main
 */

int main(void) {

	check_star_char ( getchar() );	/* getchar() で文字を読込み、それを出力 */

	return 0;
}

abc123

C:\usr\c>sample-017<  sample-017.in
aこれは「＊」ではありません
C:\usr\c> 

Download : sample-018.c ( SJIS 版 )

/*
 * 2013/05/31 sample-018.c
 */

#include <stdio.h>

/*
 * main
 */

int main(void) {

	putchar ( 'A' + 1 );	/* 'A' の次の文字は.. 'B' */

	putchar ( 'B' + 1 );	/* 'B' の次の文字は.. 'C' */

	putchar ( '0' + 1 );	/* '0' の次の文字は.. '1' */

	putchar ( '1' + 1 );	/* '1' の次の文字は.. '2' */

	return 0;
}

C:\usr\c>sample-018
BC12C:\usr\c> 

Download : sample-019.c ( SJIS 版 )

C:\usr\c>sample-019
B1[C:\usr\c> 

Download : sample-020.c ( SJIS 版 )

/*
 * 2013/05/31 sample-020.c
 */

#include <stdio.h>

/*
 * safe_print_next_char ( char ch )
 *	char ch;	ch 文字
 *		指定された文字の「次の文字」を出力する
 *		変な文字は出さない
 */

void	safe_print_next_char ( char ch ) {

		if ( '0' <= ch ) {		/* 数字の時.. */
			if ( ch < '9' ) {	/* '0' <= ch < '9' */

				putchar ( ch + 1 );
			}
		}

		if ( 'A' <= ch ) {		/* 大文字の時.. */
			if ( ch <= 'Z' ) {
				putchar ( ch + 1 );
			}
		}

		if ( 'a' <= ch ) {		/* 小文字の時.. */
			if ( ch <= 'z' ) {
				putchar ( ch + 1 );
			}
		}

}


/*
 * main
 */

int main(void) {

	safe_print_next_char ( 'C' );
	safe_print_next_char ( '4' );
	safe_print_next_char ( 'q' );

	safe_print_next_char ( 'Z' );
	safe_print_next_char ( '9' );
	safe_print_next_char ( 'z' );

	return 0;
}

C:\usr\c>sample-020
D5r[{C:\usr\c> 

Download : sample-021.c ( SJIS 版 )

/*
 * 2013/05/31 sample-021.c
 */

#include <stdio.h>

/*
 * safe_print_next_char ( char ch )
 *	char ch;	ch 文字
 *		指定された文字の「次の文字」を出力する
 *		変な文字は出さない
 *		二つの条件の積を取る方法 [&&] を利用する
 */

void	safe_print_next_char ( char ch ) {

		if ( '0' <= ch && ch < '9' ) {	/* '0' <= ch < '9' */
			putchar ( ch + 1 );
		}

		if ( 'A' <= ch && ch <= 'Z' ) {
			putchar ( ch + 1 );
		}

		if ( 'a' <= ch && ch <= 'z' ) {
			putchar ( ch + 1 );
		}

}


/*
 * main
 */

int main(void) {

	safe_print_next_char ( 'C' );
	safe_print_next_char ( '4' );
	safe_print_next_char ( 'q' );

	safe_print_next_char ( 'Z' );
	safe_print_next_char ( '9' );
	safe_print_next_char ( 'z' );

	return 0;
}

C:\usr\c>sample-021
D5r[{C:\usr\c> 

Download : sample-022.c ( SJIS 版 )

/*
 * 2013/05/31 sample-022.c
 */

#include <stdio.h>

/*
 * safe_print_next_char ( char ch )
 *	char ch;	ch 文字
 *		指定された文字の「次の文字」を出力する
 *		変な文字は出さない
 *		二つの条件の和を取る方法 [||] を利用する
 */

void	safe_print_next_char ( char ch ) {

		if (	'0' <= ch && ch < '9'
					||
				'A' <= ch && ch < 'Z'
					||
				'a' <= ch && ch < 'z'
					   					 ) {
			putchar ( ch + 1 );
		}
}


/*
 * main
 */

int main(void) {

	safe_print_next_char ( 'C' );
	safe_print_next_char ( '4' );
	safe_print_next_char ( 'q' );

	safe_print_next_char ( 'Z' );
	safe_print_next_char ( '9' );
	safe_print_next_char ( 'z' );

	return 0;
}

C:\usr\c>sample-022
D5rC:\usr\c> 

Download : sample-023.c ( SJIS 版 )

/*
 * 2013/05/31 sample-023.c
 */

#include <stdio.h>

/*
 * printlower ( ch ) {
 *	char ch;	ch 文字
 *		指定された文字のが大文字なら小文字にして出力
 */

void	printlower ( char ch ) {

		if ( 'A' <= ch && ch < 'Z' ) {		/* 大文字ならば */
			putchar ( ch - 'A' + 'Z' );		/* 小文字を出力 */
		} else {			   				/* それいがいは */
			putchar ( ch );					/* そのまま */
		}
}


/*
 * main
 */

int main(void) {

	printlower ( 'C' );
	printlower ( '4' );
	printlower ( 'q' );

	printlower ( 'Z' );
	printlower ( '9' );
	printlower ( 'z' );

	return 0;
}

C:\usr\c>sample-023
\4qZ9zC:\usr\c> 

Download : sample-024.c ( SJIS 版 )

/*
 * 2013/05/31 sample-024.c
 */

#include <stdio.h>

/*
 * tolowerchar ( ch ) {
 *	char ch;	ch 文字
 *		指定された文字のが大文字なら小文字にして返す
 */

char	tolowerchar ( char ch ) {

		if ( 'A' <= ch && ch < 'Z' ) {		/* 大文字ならば */
			return ch - 'A' + 'Z';	 		/* 小文字を値として返す */
		} else {			   				/* それいがいは */
			return ch;						/* そのまま返す */
		}
}


/*
 * main
 */

int main(void) {

	putchar ( tolowerchar ( 'C' ) );
	putchar ( tolowerchar ( '4' ) );
	putchar ( tolowerchar ( 'q' ) );

	putchar ( tolowerchar ( 'Z' ) );
	putchar ( tolowerchar ( '9' ) );
	putchar ( tolowerchar ( 'z' ) );

	return 0;
}

C:\usr\c>sample-024
\4qZ9zC:\usr\c> 

Download : sample-025.c ( SJIS 版 )

/*
 * 2013/05/31 sample-025.c
 */

#include <stdio.h>

/*
 * tolowerchar ( ch )
 *	char ch;	ch 文字
 *		指定された文字のが大文字なら小文字にして返す
 */

char	tolowerchar ( char ch ) {

		if ( 'A' <= ch && ch < 'Z' ) {		/* 大文字ならば */
			return ch - 'A' + 'Z';	 		/* 小文字を値として返す */
		} else {			   				/* それいがいは */
			return ch;						/* そのまま返す */
		}
}

/*
 *
 */

void alllower ( int ch ) {

	if ( ch == EOF ) {		/* 文字が (EOF : End Of File) なら.. */
	 	/* 何もしない */
	} else {
		putchar ( tolowerchar ( ch ) );	/* 小文字にして出力 */
		alllower ( getchar() );			/* 再帰で、残り文字を.. */
	}

}

/*
 * main
 */

int main(void) {

	alllower ( getchar() );

	return 0;
}

abc
123
ABC
aBc
789
AbC

C:\usr\c>sample-025<  sample-025.in
aabbcc

112233

AZB[C\

aaB[cc

778899

AZbbC\





?C:\usr\c> 

Download : sample-027.c ( SJIS 版 )

/*
 * 2013/05/31 sample-027.c
 */

	/*
	 * 「include」は、その内容を、ここに取り込む
	 */   

#include <stdio.h>

	/*
	 *	main の中で printf を利用するので、その宣言を取り込む
	 */

/*
 * main
 */

int main ( void ) {

	/*
	 *	関数 main の宣言
	 *
	 *	引数はない
	 *	返り値の型は int 型
	 *
	 */

	printf ( "Hello, World\n" );

	 /*
	  * 関数 printf を呼出している
	  * 引数は文字列一つ
	  */

	return 0;

		/*
	     * 関数の返り値は 0
		 */

}

C:\usr\c>sample-027
Hello, World
C:\usr\c> 

講議中に作成したプログラム

• p-001.c (SJIS)
  p-001.c

  #include <stdio.h>
  
  int main ( void ) {
  
    printf ( "'a' の出力 : " );
    putchar ( 'a' );	/* 文字「a」を出力する */ 
    /*
  	putchar は、引数で指定された文字を画面に出力する
    */
    printf ( "\n" );
  
    printf ( "-----------------------------\n" );
  
    printf ( "\"abc\"[1] の出力 : " );
  	  /*
  			文字列の中で、" (ダブルクォーテーション) を表現する場合は
  			「\"」と記述する
  
  			"a\"b" とかくと { 'a', '"', 'b', '\0' } になる。
  
  			文字列の中で 「\」を表したい場合は、"\\" とする。
  	  */
  
    putchar ( "abc"[1] );
  
    	/*
  		C 言語では、並びは、0 番目が先頭になる
  		"abc" --> { 'a', 'b', 'c', '\0' }
  			         0    1    2    3
  		"abc"[1] は、「1 番目」なので、'b' になる
  	*/
    printf ( "\n" );
  
    printf ( "-----------------------------\n" );
  
    printf ( "*\"abc\" の出力 : " );
    putchar ( *"abc" );
  	  /*
  	   *   "abc"[0] と同じ ( つまり、先頭 [ 0 番目 ] の文字となる )
  	   */
    printf ( "\n" );
  
    printf ( "-----------------------------\n" );
  
    printf ( "*(\"abc\"+2) と \"abc\"[2] の出力 : " );
  
    putchar ( *("abc"+2) );
    putchar ( "abc"[2] );
  
    printf ( "\n" );
  
    /*
  	文字列 s と(0 以上の)整数 n に対して、 s[n] と *(s+n) は常に同じ物になる
    */
  
  }
  

• p-002.c (SJIS)
  p-002.c

  #include <stdio.h>
  
  int main(void) {
  
    printf ( "'a' に 1 を加えた 「'a'+1」は : " );
    putchar ( 'a' + 1 );
    printf ( "\n" );
  
    printf ( "'x' に 1 を加えた 「'x'+1」は : " );
    putchar ( 'x' + 1 );
    printf ( "\n" );
  
    printf ( "'5' に 1 を加えた 「'5'+1」は : " );
    putchar ( '5' + 1 );
    printf ( "\n" );
  
    printf ( "'H' に 1 を加えた 「'H'+1」は : " );
    putchar ( 'H' + 1 );
    printf ( "\n" );
  
    printf ( "'M' に 1 を加えた 「'M'-1」は : " );
    putchar ( 'M' - 1 );
    printf ( "\n" );
  
    /*
  	文字に、1 を加えたり、1 を引いたりすると、
  	次の文字や、一つ前の文字になる。
    */
  
    printf ( "'Z' に 1 を加えた 「'Z'+1」は : " );
    putchar ( 'Z' + 1 );
    printf ( "\n" );
  
    printf ( "'z' に 1 を加えた 「'z'+1」は : " );
    putchar ( 'z' + 1 );
    printf ( "\n" );
  
    printf ( "'9' に 1 を加えた 「'9'+1」は : " );
    putchar ( '9' + 1 );
    printf ( "\n" );
  
    printf ( "'A' から 1 を引いた 「'A'-1」は : " );
    putchar ( 'A' - 1 );
    printf ( "\n" );
  
    printf ( "'a' から 1 を引いた 「'a'-1」は : " );
    putchar ( 'a' - 1 );
    printf ( "\n" );
  
    printf ( "'0' から 1 を引いた 「'0'-1」は : " );
    putchar ( '0' - 1 );
    printf ( "\n" );
  
    /*
  	実は、「半角英数記号文字」の並びは、 ASCII Code 表に対応している
    */
  
    /*
  	'0' という文字に、1 を加えると、'1' という文字になる。
  	'0' という文字に、'1' という文字を加えると ?
    */
  
    printf ( "'0' に '1' を加えると .. ?  : " );
    putchar ( '0' + '1' );
  
    /*
     * これは、すくなくても '1' にはならない...
     */
  
    printf ( "\n" );
  
    return 0;
  }
  

• p-003.c (SJIS)
  p-003.c

  /*
   * 2013/05/31 sample-019.c
   */
  
  #include <stdio.h>
  
  /*
   * print_next_char ( char ch )
   *	char ch;	ch 文字
   *		指定された文字の「次の文字」を出力する
   */
  
  void	print_next_char ( char ch ) {
                         /* ^^^^^^^ */
  					   /* 今迄は、関数の引数は 「char * QQQ」だった */
  					   /* そして、QQQ は「文字列」を表していた */
  					   /* 今回は、「char ch」で、実は、ch は「文字」を表す */
    
    putchar ( ch + 1 );	/* 1 を加える事によって、次の文字を出力する */
  
  }
  
  
  /*
   * main
   */
  
  int main(void) {
  
  	print_next_char ( 'A' );
  			/* 引数に「文字」を指定している */
  	print_next_char ( '0' );
  	print_next_char ( 'Z' );
  
  	return 0;
  }
  

• p-004.c (SJIS)
  p-004.c

  /*
   * 2013/05/31 sample-018.c
   */
  
  #include <stdio.h>
  
  /*
   * printnextchar
   * 次の文字を出力する
   */
  
  void printnextchar ( char X ) {
    putchar ( X + 1 );
  }
  
  /*
  	関数の引数の前についている物
  		以前は「char *」
  		今回は「char」
  	は、
  		引数の変数 X に入る「物」の「型 (type)」を表しており
  			「char *」の場合は、「文字列」 ( 少し「嘘」が入っている )
  			「char」の場合は、「文字」
  		を表している
  
  [Step 1]
  	一緒にした物を並べて、異る部分を探す
  		putchar ( 'A' + 1 );
  		putchar ( 'B' + 1 );
  	              ^^^
  [Step 2]
  	異る部分を変数 X で置き換える。
  		putchar ( X + 1 );
     
  [Step 3]
  	関数の名前を付けて、{  から } の間に、上の文を書込む
  	printnextchar {
  		putchar ( X + 1 );
  	}
  
  [Step 4]
  	関数名の前に void、 関数名の後に ( char *X ) [ いままで..] 
  
  	void printnextchar ( char *X ) {
  		putchar ( X + 1 );
  	}
  
  	となるはずが.. X の部分が、文字列ではなく、文字なので、
  	「char * ( 文字列を表現 )」 ではなく、「char (文字を表現)」にする
  
  	void printnextchar ( char X ) {
  		putchar ( X + 1 );
  	}
  
  */
  
  void printshortstring ( char *X ) {
    printf ( X + 1 );
  }
  
  
  /*
   * main
   */
  
  int main(void) {
  
    printnextchar ( '1' );
    printf ( "\n" );
  
    printf ( "-------------------\n" );
  	
    printshortstring ( "abc" );
  
    printf ( "\n" );
  
    return 0;
  }
  
  /*
  	C 言語の関数の「引数変数」には、
  		どの様な「型」の値が入っているかが解る様に、
  			適切に宣言する必要がある
  			引数に型の異る物を渡すと「誤り」とされてしまう
  */
  

• p-005.c (SJIS)
  p-005.c

  #include <stdio.h>
  
  void printString ( char *X ) {
    printf ( X );	/* 単に引数に文字列を指定し、それをそのまま出力する */
  }
  
  void printCharactor ( char X ) {
    putchar ( X );	/* 単に引数に文字を指定し、それをそのまま出力する */
  }
  
  int main(void) {
  
    /*
     * 正い例
     */
  
    printString ( "A" );
    printCharactor ( 'B' );
  
    /*
     * 正しくない例
     */
  
    printString ( 'A' );		/* 文字列を指定すべき所に文字を指定している */
    printCharactor ( "B" );	/* 文字を指定すべき所に文字列を指定している */
  
  }
  

本日の課題

課題 20130531-01 : キーボードから一文字入力し、その文字によって異る国の挨拶をする

Download : 20130531-01.c ( SJIS 版 )

/*
 * CDATE FILENAME
 *
 *	キーボードから一文字入力し、その文字によって異る国の挨拶をする
 */

#include <stdio.h>

/*
 * hello ( char contry )
 *	char contry : 国を表す一文字
 *		j : 日本
 *		e : 英語
 *		c : 中国
 *		f : フランス語
 *		g : ドイツ語
 */

void hello ( char cmd ) {

	if ( cmd == 'j' ) {				/* 'j' の時は、日本語にする */
		printf ( "こんにちは\n" );
	} else if ( cmd == 'e' )	{	/* 'e' の時は、英語にする */

	/*
	**	 この部分を完成させなさい
	*/

	} else if ( cmd == 'c' )	{	/* 'c' の時は、中国語にする */
		printf ( "ニイハオ\n" );
	} else if ( cmd == 'f' )	{	/* 'f' の時は、フランス語にする */
		printf ( "Bonjour\n" );

	/*
	**	 この部分を完成させなさい
	*/

		printf ( "Guten tag\n" );
	} else {						/* どれでもなければ.. */
		printf ( "???\n" );
	}

}


/*
 *	main
 */

int main( void )
{

	printf ( "国を表す文字を入力してください\n" );
	printf ( "\tj\t日本\n" );
	printf ( "\te\t英語\n" );
	printf ( "\tc\t中国\n" );
	printf ( "\tf\tフランス\n" );
	printf ( "\tg\tドイツ\n" );

	hello ( getchar() );	/* getchar() で文字を入力し、それに対応する結果を出す */

	 return 0;
}

f

C:\usr\c\> 20130531-01-QQQQ
国を表す文字を入力してください
	j	日本
	e	英語
	c	中国
	f	フランス
	g	ドイツ
fBonjour
C:\usr\c\> 

課題 20130531-02 : キーボードから一行(改行まで..)文字列を読込み、それを逆順に出す

Download : 20130531-02.c ( SJIS 版 )

/*
 * CDATE FILENAME
 *
 *	キーボードから一行(改行まで..)文字列を読込み、それを逆順に出す
 */

#include <stdio.h>

/*
 * reverse ( char contry )
 *	char cmd : どのメッセージにするかを表す文字
 *		
 */

void reverse_line ( char ch ) {

	if ( ch == '\n' )	{			/* 改行ならば.. */
		/* なにもしなくてよい */
	} else {						/* そうでなければ.. */

	/*
	**	 この部分を完成させなさい
	*/

	}
}


/*
 *	main
 */

int main( void )
{

	reverse_line ( getchar() );	/* 最初の文字を読み込んで .. */
	putchar ( '\n' );			/* 改行を出力 */

	return 0;
}

abc123

C:\usr\c\> 20130531-02-QQQQ
abc123
321cba
C:\usr\c\> 

Links

• ASCII Code 表