ソフトウェア概論B (2011/06/24)
Ver. 1.0

目次

講義資料

当日の OHP 資料

当日のOHP資料です。

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

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

sample-001

Download : sample-001.c ( SJIS 版 )

/*
 * 2011/06/24 sample-001.c
 */

/*
 * sizeof 演算子
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

void print_size_of_type ( char *name, int size ) {

  s_print_string ( "sizeof ( " );
  s_print_string ( name );
  s_print_string ( " ) = " );
  s_print_int ( size );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  print_size_of_type ( "char", sizeof( char ) );
  print_size_of_type ( "int", sizeof( int ) );
  print_size_of_type ( "double", sizeof( double ) );
  print_size_of_type ( "char *", sizeof( char * ) );

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-001
sizeof ( char ) = 1
sizeof ( int ) = 4
sizeof ( double ) = 8
sizeof ( char * ) = 4
C:\usr\c\> 

sample-002

Download : sample-002.c ( SJIS 版 )

/*
 * 2011/06/24 sample-002.c
 */

/*
 * 2 進数表示 ( 8 bit )
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	CHAR_BIT_SIZE	( 8 * sizeof ( char ) )		/* char 型の bit 長さ */

/*
 *
 */

void print_binary_digit ( char number, int digits ) {

  if ( digits <= 0 ) {
	/* 全ての桁を表示したのでやることなし */
  } else {
	print_binary_digit ( number / 2, digits - 1 );	/* とりあえず上位の桁を表示 */
	s_print_int ( number % 2 );						/* 最下位の桁一桁を表示 */
  }
}

/*
 *
 */

void print_char_and_bin ( char number ) {

  print_binary_digit ( number, CHAR_BIT_SIZE );
  s_print_string ( " == " );
  s_print_int ( number );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  print_char_and_bin ( 1 );
  print_char_and_bin ( 2 );
  print_char_and_bin ( 3 );
  print_char_and_bin ( 10 );
  print_char_and_bin ( 100 );

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-002
00000001 == 1
00000010 == 2
00000011 == 3
00001010 == 10
01100100 == 100
C:\usr\c\> 

sample-003

Download : sample-003.c ( SJIS 版 )

/*
 * 2011/06/24 sample-003.c
 */

/*
 * 1 の補数 / 2 の補数 ( 8 bit )
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	CHAR_BIT_SIZE	( 8 * sizeof ( char ) )		/* char 型の bit 長さ */

/*
 *
 */

void print_binary_digit ( unsigned char number, int digits ) {

  if ( digits <= 0 ) {
	/* 全ての桁を表示したのでやることなし */
  } else {
	print_binary_digit ( number / 2, digits - 1 );	/* とりあえず上位の桁を表示 */
	s_print_int ( number % 2 );						/* 最下位の桁一桁を表示 */
  }
}

/*
 *
 */

void print_one_negative ( unsigned char number, int digits ) {

  if ( digits <= 0 ) {
	/* 全ての桁を表示したのでやることなし */
  } else {
	print_one_negative ( number / 2, digits - 1 );	/* とりあえず上位の桁を表示 */
	s_print_int ( ( 1 + 0 ) - number % 2 );			/* 最下位の桁一桁を 0/1 反転させて表示 */
  }
}

/*
 *
 */

void print_negatives ( char number ) {

  s_print_int ( number );
  s_print_newline();
  s_print_string ( "  元の数 : " );
  print_binary_digit ( (unsigned char)number, CHAR_BIT_SIZE );
  s_print_newline();
  s_print_string ( "一の補数 : " );
  print_one_negative ( (unsigned char)number, CHAR_BIT_SIZE );
  s_print_newline();
  s_print_string ( "二の補数 : " );
print_binary_digit ( (unsigned char)(-number), CHAR_BIT_SIZE );	/* 負の数は、実は \
    2 補数になっている.. */
  s_print_newline();
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  print_negatives ( 0 );
  print_negatives ( 1 );
  print_negatives ( 2 );
  print_negatives ( 5 );
  print_negatives ( 10 );
  print_negatives ( 72 );

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-003
0
  元の数 : 00000000
一の補数 : 11111111
二の補数 : 00000000

1
  元の数 : 00000001
一の補数 : 11111110
二の補数 : 11111111

2
  元の数 : 00000010
一の補数 : 11111101
二の補数 : 11111110

5
  元の数 : 00000101
一の補数 : 11111010
二の補数 : 11111011

10
  元の数 : 00001010
一の補数 : 11110101
二の補数 : 11110110

72
  元の数 : 01001000
一の補数 : 10110111
二の補数 : 10111000

C:\usr\c\> 

sample-004

Download : sample-004.c ( SJIS 版 )

/*
 * 2011/06/24 sample-003.c
 */

/*
 * 負の数と二の補数 ( 8 bit )
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	CHAR_BIT_SIZE	( 8 * sizeof ( char ) )		/* char 型の bit 長さ */

/*
 *
 */

void print_binary_digit ( unsigned char number, int digits ) {

  if ( digits <= 0 ) {
	/* 全ての桁を表示したのでやることなし */
  } else {
	print_binary_digit ( number / 2, digits - 1 );	/* とりあえず上位の桁を表示 */
	s_print_int ( number % 2 );						/* 最下位の桁一桁を表示 */
  }
}

/*
 *
 */

void print_char_and_bin ( char number ) {

  print_binary_digit ( (unsigned char)number, CHAR_BIT_SIZE );
  s_print_string ( " == " );
  s_print_int ( number );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  print_char_and_bin ( 0 );
  print_char_and_bin ( -0 );

  print_char_and_bin ( 1 );
  print_char_and_bin ( -1 );

  print_char_and_bin ( 72 );
  print_char_and_bin ( -72 );

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-004
00000000 == 0
00000000 == 0
00000001 == 1
11111111 == -1
01001000 == 72
10111000 == -72
C:\usr\c\> 

sample-005

Download : sample-005.c ( SJIS 版 )

/*
 * 2011/06/24 sample-005.c
 */

/*
 * 負の数の 2 進数表示 ( 32 bit : int 型 )
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	INT_BIT_SIZE	( 8 * sizeof ( int ) )		/* int 型の bit 長さ */

/*
 *
 */

void print_binary_digit ( unsigned int number, int digits ) {

  if ( digits <= 0 ) {
	/* 全ての桁を表示したのでやることなし */
  } else {
	print_binary_digit ( number / 2, digits - 1 );	/* とりあえず上位の桁を表示 */
	s_print_int ( number % 2 );						/* 最下位の桁一桁を表示 */
  }
}

/*
 *
 */

void print_dec_and_bin ( int number ) {

  print_binary_digit ( (unsigned int)number, INT_BIT_SIZE );
  s_print_string ( " == " );
  s_print_int ( number );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  print_dec_and_bin ( 10 );
  print_dec_and_bin ( -10 );

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-005
00000000000000000000000000001010 == 10
11111111111111111111111111110110 == -10
C:\usr\c\> 

sample-006

Download : sample-006.c ( SJIS 版 )

/*
 * 2011/06/24 sample-006.c
 */

/*
 * 論理演算
 */

#include <stdio.h>
#include "s_print.h"

/*
 *	論理値 ( 真/偽 ) を、1 bit の整数値で表現
 */

#define	TRUE	1		/* 「真」を 1 で表現 */
#define	FALSE	0		/* 「偽」を 0 で表現 */

#define Boolean	int		/* Boolean (真偽値) を int でコーディングする事にする */

/*
 *	print_boolean ( Boolean a )
 */

void print_boolean ( Boolean a )	/* 真偽値を表示 */
{

  if ( a == TRUE ) {		/* a が真ならば.. */
	s_print_string ( "True" );
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	s_print_string ( "False" );
  }
}

/*
 * boolean_and ( Boolean a, Boolean b ) == a & b
 */

int boolean_and ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真で、.. */
	if ( b == TRUE ) {		/* しかも b も真ならば.. */
	  return TRUE;			/* a and b は真 */
	} else {				/* b が真でないので ( 多分、偽だから.. ) */
	  return FALSE;			/* 偽を返す */
	}
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	return FALSE;			/* b を見るまでもなく偽を返す */
  }
}

/*
 * boolean_or ( Boolean a, Boolean b ) == a & b
 */

int boolean_or ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return TRUE;			/* b と無関係に真 */
  } else if ( b == TRUE ) { /* a が偽でも b が真なら.. */
	return TRUE;			/* やっぱり真 */
  } else {					/* いずれでもなければ.. */
	return FALSE;			/* 偽となる */
  }
}

/*
 * boolean_not ( Boolean a ) == ~ a
 */

int boolean_not ( Boolean a ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return FALSE;			/* 偽となる */
  } else {					/* そうでなければ.. */
	return TRUE;			/* 真となる */
  }
}

/*
 * boolean_xor ( Boolean a, Boolean b ) == a ^ b
 */

int boolean_xor ( Boolean a, Boolean b ) {

  if ( a != b ) {			/* もし、 a と b が異れば */
	return TRUE;			/* 真となる */
  } else {					/* それ以外は */
	return FALSE;			/* 偽となる */
  }
}

/*
 * print_or ( Boolean a, Boolean b )
 */

void print_or ( Boolean a, Boolean b ) {

  print_boolean ( a );
  s_print_string ( " | " );
  print_boolean ( b );
  s_print_string ( " == " );
  print_boolean ( boolean_or ( a, b ) );
  s_print_newline();

}

/*
 * print_and ( Boolean a, Boolean b )
 */

void print_and ( Boolean a, Boolean b ) {

  print_boolean ( a );
  s_print_string ( " & " );
  print_boolean ( b );
  s_print_string ( " == " );
  print_boolean ( boolean_and ( a, b ) );
  s_print_newline();

}

/*
 * print_not ( Boolean a, Boolean b )
 */

void print_not ( Boolean a ) {

  s_print_string ( "~ " );
  print_boolean ( a );
  s_print_string ( " == " );
  print_boolean ( boolean_not ( a ) );
  s_print_newline();

}

/*
 * print_xor ( Boolean a, Boolean b )
 */

void print_xor ( Boolean a, Boolean b ) {

  print_boolean ( a );
  s_print_string ( " ^ " );
  print_boolean ( b );
  s_print_string ( " == " );
  print_boolean ( boolean_xor ( a, b ) );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  s_print_string ( "[and]\n" );
  print_and ( TRUE, TRUE );
  print_and ( TRUE, FALSE );
  print_and ( FALSE, TRUE );
  print_and ( FALSE, FALSE );
  s_print_newline();

  s_print_string ( "[or]\n" );
  print_or ( TRUE, TRUE );
  print_or ( TRUE, FALSE );
  print_or ( FALSE, TRUE );
  print_or ( FALSE, FALSE );
  s_print_newline();

  s_print_string ( "[not]\n" );
  print_not ( TRUE );
  print_not ( FALSE );
  s_print_newline();

  s_print_string ( "[xor]\n" );
  print_xor ( TRUE, TRUE );
  print_xor ( TRUE, FALSE );
  print_xor ( FALSE, TRUE );
  print_xor ( FALSE, FALSE );
  s_print_newline();

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-006
[and]
True & True == True
True & False == False
False & True == False
False & False == False

[or]
True | True == True
True | False == True
False | True == True
False | False == False

[not]
~ True == False
~ False == True

[xor]
True ^ True == False
True ^ False == True
False ^ True == True
False ^ False == False

C:\usr\c\> 

sample-007

Download : sample-007.c ( SJIS 版 )

/*
 * 2011/06/24 sample-007.c
 */

/*
 * 論理演算による一ビットの数の和の計算
 */

#include <stdio.h>
#include "s_print.h"

/*
 *	論理値 ( 真/偽 ) を、1 bit の整数値で表現
 */

#define	TRUE	1		/* 「真」を 1 で表現 */
#define	FALSE	0		/* 「偽」を 0 で表現 */

#define Boolean	int		/* Boolean (真偽値) を int でコーディングする事にする */

/*
 *	print_boolean ( Boolean a )
 */

void print_boolean ( Boolean a )	/* 真偽値を表示 */
{

  if ( a == TRUE ) {		/* a が真ならば.. */
	s_print_string ( "True" );
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	s_print_string ( "False" );
  }
}

/*
 * boolean_and ( Boolean a, Boolean b ) == a & b
 */

int boolean_and ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真で、.. */
	if ( b == TRUE ) {		/* しかも b も真ならば.. */
	  return TRUE;			/* a and b は真 */
	} else {				/* b が真でないので ( 多分、偽だから.. ) */
	  return FALSE;			/* 偽を返す */
	}
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	return FALSE;			/* b を見るまでもなく偽を返す */
  }
}

/*
 * boolean_or ( Boolean a, Boolean b ) == a & b
 */

int boolean_or ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return TRUE;			/* b と無関係に真 */
  } else if ( b == TRUE ) { /* a が偽でも b が真なら.. */
	return TRUE;			/* やっぱり真 */
  } else {					/* いずれでもなければ.. */
	return FALSE;			/* 偽となる */
  }
}

/*
 * boolean_not ( Boolean a ) == ~ a
 */

int boolean_not ( Boolean a ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return FALSE;			/* 偽となる */
  } else {					/* そうでなければ.. */
	return TRUE;			/* 真となる */
  }
}

/*
 * boolean_xor ( Boolean a, Boolean b ) == a ^ b
 */

int boolean_xor ( Boolean a, Boolean b ) {

  if ( a != b ) {			/* もし、 a と b が異れば */
	return TRUE;			/* 真となる */
  } else {					/* それ以外は */
	return FALSE;			/* 偽となる */
  }
}

/*
 *	print_half_adder ( Boolean a, Boolean b ) : 一桁の二進数の和の計算を、論理演算で行う
 */

void print_half_adder ( Boolean a, Boolean b ) {

  s_print_int ( boolean_and ( a, b ) );		/* 二桁目は、二つの数の論理積 */
  s_print_int ( boolean_xor ( a, b ) );		/* 一桁目は、二つの数の排他論理和 (論理差) */
}

/*
 *	print_1bit_add ( Boolean a, Boolean b ) : 一桁の二進数の和の計算の表示
 */

void print_1bit_add ( Boolean a, Boolean b ) {

  s_print_int ( a );
  s_print_string ( " + " );
  s_print_int ( b );
  s_print_string ( " == " );
  print_half_adder ( a, b );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  s_print_string ( "一ビットの数の和\n" );
  print_1bit_add ( 0, 0 );
  print_1bit_add ( 1, 0 );
  print_1bit_add ( 0, 1 );
  print_1bit_add ( 1, 1 );
 
  return 0;
}

/*
 *
 */

C:\usr\c\> sample-007
一ビットの数の和
0 + 0 == 00
1 + 0 == 01
0 + 1 == 01
1 + 1 == 10
C:\usr\c\> 

sample-008

Download : sample-008.c ( SJIS 版 )

/*
 * 2011/06/24 sample-008.c
 */

/*
 * 論理演算による二進数の和の計算
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	CHAR_BIT_SIZE	( 8 * sizeof ( char ) )		/* char 型の bit 長さ */

/*
 *
 */

void print_binary_digit ( unsigned int number, int digits ) {

  if ( digits <= 0 ) {
	/* 全ての桁を表示したのでやることなし */
  } else {
	print_binary_digit ( number / 2, digits - 1 );	/* とりあえず上位の桁を表示 */
	s_print_int ( number % 2 );						/* 最下位の桁一桁を表示 */
  }
}

/*
 *	論理値 ( 真/偽 ) を、1 bit の整数値で表現
 */

#define	TRUE	1		/* 「真」を 1 で表現 */
#define	FALSE	0		/* 「偽」を 0 で表現 */

#define Boolean	int		/* Boolean (真偽値) を int でコーディングする事にする */

/*
 *	print_boolean ( Boolean a )
 */

void print_boolean ( Boolean a )	/* 真偽値を表示 */
{

  if ( a == TRUE ) {		/* a が真ならば.. */
	s_print_string ( "True" );
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	s_print_string ( "False" );
  }
}

/*
 * boolean_and ( Boolean a, Boolean b ) == a & b
 */

int boolean_and ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真で、.. */
	if ( b == TRUE ) {		/* しかも b も真ならば.. */
	  return TRUE;			/* a and b は真 */
	} else {				/* b が真でないので ( 多分、偽だから.. ) */
	  return FALSE;			/* 偽を返す */
	}
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	return FALSE;			/* b を見るまでもなく偽を返す */
  }
}

/*
 * boolean_or ( Boolean a, Boolean b ) == a & b
 */

int boolean_or ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return TRUE;			/* b と無関係に真 */
  } else if ( b == TRUE ) { /* a が偽でも b が真なら.. */
	return TRUE;			/* やっぱり真 */
  } else {					/* いずれでもなければ.. */
	return FALSE;			/* 偽となる */
  }
}

/*
 * boolean_not ( Boolean a ) == ~ a
 */

int boolean_not ( Boolean a ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return FALSE;			/* 偽となる */
  } else {					/* そうでなければ.. */
	return TRUE;			/* 真となる */
  }
}

/*
 * boolean_xor ( Boolean a, Boolean b ) == a ^ b
 */

int boolean_xor ( Boolean a, Boolean b ) {

  if ( a != b ) {			/* もし、 a と b が異れば */
	return TRUE;			/* 真となる */
  } else {					/* それ以外は */
	return FALSE;			/* 偽となる */
  }
}

/*
* calc_carray_with_carray ( Boolean a, Boolean b, Boolean carray )	三つの 1 \
    bit の数の繰り上がりの計算をする
 */

Boolean calc_carray_with_carray ( Boolean a, Boolean b, Boolean carray ) {

return boolean_or ( boolean_and ( a, b ), boolean_or ( boolean_and ( a, \
    carray ), boolean_and ( b, carray ) ) );
}

/*
* calc_1bit_with_carray ( Boolean a, Boolean b, Boolean carray )	三つの 1 bit \
    の数の一桁目を計算する
 */

Boolean calc_1bit_with_carray ( Boolean a, Boolean b, Boolean carray ) {

  return boolean_xor ( boolean_xor ( a, b ), carray );
}

/*
*	print_nbit_adder_with_carray ( unsigned int aa, unsigned int bb, Boolean \
    carray, int digits )		繰り上がり付きの計算
 */

void print_nbit_adder_with_carray ( unsigned int aa, unsigned int bb, \
    Boolean carray, int digits ) {

  if ( digits <= 0 ) {			/* 全ての桁を計算したので .. */
	s_print_int ( carray );		/* 繰り上がりを表示 */
  } else {						/* そうでなければ.. */
	print_nbit_adder_with_carray ( aa / 2, bb / 2, calc_carray_with_carray ( \
    aa % 2, bb % 2, carray ), digits - 1 );
								/* 繰り上がり付きで、上位桁を表示 : 再帰呼出 */
	s_print_int ( calc_1bit_with_carray ( aa % 2, bb % 2, carray ) );
								/* 繰り上がり付きで、最下位桁を表示 */
  }
}

/*
 *	print_nbit_adder ( int aa, int bb )		n bit の和の計算
 */

void print_nbit_adder ( int aa, int bb ) {

  print_binary_digit ( aa, CHAR_BIT_SIZE );
  s_print_string ( " + " );
  print_binary_digit ( bb, CHAR_BIT_SIZE );
  s_print_string ( " == " );
  print_nbit_adder_with_carray ( aa, bb, 0, CHAR_BIT_SIZE );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  s_print_string ( "76543210   76543210    876543210\n" );
  print_nbit_adder ( 0, 0 );
  print_nbit_adder ( 1, 0 );
  print_nbit_adder ( 0, 1 );
  print_nbit_adder ( 1, 1 );

  print_nbit_adder ( 3, 5 );
  print_nbit_adder ( 10, 20 );
  print_nbit_adder ( 11, 21 );
 
  return 0;
}

/*
 *
 */

C:\usr\c\> sample-008
76543210   76543210    876543210
00000000 + 00000000 == 000000000
00000001 + 00000000 == 000000001
00000000 + 00000001 == 000000001
00000001 + 00000001 == 000000010
00000011 + 00000101 == 000001000
00001010 + 00010100 == 000011110
00001011 + 00010101 == 000100000
C:\usr\c\> 

sample-009

Download : sample-009.c ( SJIS 版 )

/*
 * 2011/06/24 sample-009.c
 */

/*
 * 二進数の和の計算でのオーバーフロー
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	CHAR_BIT_SIZE	( 8 * sizeof ( char ) )		/* char 型の bit 長さ */

/*
 *
 */

void print_binary_digit ( unsigned int number, int digits ) {

  if ( digits <= 0 ) {
	/* 全ての桁を表示したのでやることなし */
  } else {
	print_binary_digit ( number / 2, digits - 1 );	/* とりあえず上位の桁を表示 */
	s_print_int ( number % 2 );						/* 最下位の桁一桁を表示 */
  }
}

/*
 *	論理値 ( 真/偽 ) を、1 bit の整数値で表現
 */

#define	TRUE	1		/* 「真」を 1 で表現 */
#define	FALSE	0		/* 「偽」を 0 で表現 */

#define Boolean	int		/* Boolean (真偽値) を int でコーディングする事にする */

/*
 *	print_boolean ( Boolean a )
 */

void print_boolean ( Boolean a )	/* 真偽値を表示 */
{

  if ( a == TRUE ) {		/* a が真ならば.. */
	s_print_string ( "True" );
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	s_print_string ( "False" );
  }
}

/*
 * boolean_and ( Boolean a, Boolean b ) == a & b
 */

int boolean_and ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真で、.. */
	if ( b == TRUE ) {		/* しかも b も真ならば.. */
	  return TRUE;			/* a and b は真 */
	} else {				/* b が真でないので ( 多分、偽だから.. ) */
	  return FALSE;			/* 偽を返す */
	}
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	return FALSE;			/* b を見るまでもなく偽を返す */
  }
}

/*
 * boolean_or ( Boolean a, Boolean b ) == a & b
 */

int boolean_or ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return TRUE;			/* b と無関係に真 */
  } else if ( b == TRUE ) { /* a が偽でも b が真なら.. */
	return TRUE;			/* やっぱり真 */
  } else {					/* いずれでもなければ.. */
	return FALSE;			/* 偽となる */
  }
}

/*
 * boolean_not ( Boolean a ) == ~ a
 */

int boolean_not ( Boolean a ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return FALSE;			/* 偽となる */
  } else {					/* そうでなければ.. */
	return TRUE;			/* 真となる */
  }
}

/*
 * boolean_xor ( Boolean a, Boolean b ) == a ^ b
 */

int boolean_xor ( Boolean a, Boolean b ) {

  if ( a != b ) {			/* もし、 a と b が異れば */
	return TRUE;			/* 真となる */
  } else {					/* それ以外は */
	return FALSE;			/* 偽となる */
  }
}

/*
* calc_carray_with_carray ( Boolean a, Boolean b, Boolean carray )	三つの 1 \
    bit の数の繰り上がりの計算をする
 */

Boolean calc_carray_with_carray ( Boolean a, Boolean b, Boolean carray ) {

return boolean_or ( boolean_and ( a, b ), boolean_or ( boolean_and ( a, \
    carray ), boolean_and ( b, carray ) ) );
}

/*
* calc_1bit_with_carray ( Boolean a, Boolean b, Boolean carray )	三つの 1 bit \
    の数の一桁目を計算する
 */

Boolean calc_1bit_with_carray ( Boolean a, Boolean b, Boolean carray ) {

  return boolean_xor ( boolean_xor ( a, b ), carray );
}

/*
*	print_nbit_adder_with_carray ( unsigned int aa, unsigned int bb, Boolean \
    carray, int digits )		繰り上がり付きの計算
 */

void print_nbit_adder_with_carray ( unsigned int aa, unsigned int bb, \
    Boolean carray, int digits ) {

  if ( digits <= 0 ) {			/* 全ての桁を計算したので .. */
	s_print_int ( carray );		/* 繰り上がりを表示 */
  } else {						/* そうでなければ.. */
	print_nbit_adder_with_carray ( aa / 2, bb / 2, calc_carray_with_carray ( \
    aa % 2, bb % 2, carray ), digits - 1 );
								/* 繰り上がり付きで、上位桁を表示 : 再帰呼出 */
	s_print_int ( calc_1bit_with_carray ( aa % 2, bb % 2, carray ) );
								/* 繰り上がり付きで、最下位桁を表示 */
  }
}

/*
 *	print_nbit_adder ( int aa, int bb )		n bit の和の計算
 */

void print_nbit_adder ( int aa, int bb ) {

  print_binary_digit ( aa, CHAR_BIT_SIZE );
  s_print_string ( " + " );
  print_binary_digit ( bb, CHAR_BIT_SIZE );
  s_print_string ( " == " );
  print_nbit_adder_with_carray ( aa, bb, 0, CHAR_BIT_SIZE );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  s_print_string ( "76543210   76543210    876543210\n" );
  print_nbit_adder ( 126, 1 );
  print_nbit_adder ( 127, 1 );
  print_nbit_adder ( -128,0 );

  print_nbit_adder ( -127, -1 );
  print_nbit_adder ( -128, -1 );
 
  return 0;
}

/*
 *
 */

C:\usr\c\> sample-009
76543210   76543210    876543210
01111110 + 00000001 == 001111111
01111111 + 00000001 == 010000000
10000000 + 00000000 == 010000000
10000001 + 11111111 == 110000000
10000000 + 11111111 == 101111111
C:\usr\c\> 

sample-010

Download : sample-010.c ( SJIS 版 )

/*
 * 2011/06/24 sample-010.c
 */

/*
 * 整数計算でのオーバーフロー
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

int main ( void ) {

  s_print_string ( "2147483646 + 1 = " );
  s_print_int ( 2147483646 + 1 );
  s_print_newline();

  s_print_string ( "2147483647 + 1 = " );
  s_print_int ( 2147483647 + 1 );
  s_print_newline();

  s_print_string ( "-2147483647 - 1 = " );
  s_print_int ( -2147483647 - 1 );
  s_print_newline();

  s_print_string ( "-2147483648 - 1 = " );
  s_print_int ( -2147483648 - 1 );
  s_print_newline();
 
  return 0;
}

/*
 *
 */

C:\usr\c\> sample-010
2147483646 + 1 = 2147483647
2147483647 + 1 = -2147483648
-2147483647 - 1 = -2147483648
-2147483648 - 1 = 2147483647
C:\usr\c\> 

sample-011

Download : sample-011.c ( SJIS 版 )

/*
 * 2011/06/24 sample-011.c
 */

/*
 *	ポインター演算子 ( 「&」) と、間接参照演算子 ( 「*」 )
 */

#include <stdio.h>
#include "s_print.h"

/*
 *	ポインター値による、間接参照
 */

void int_poiner_arg_func ( int *pv ) {

  s_print_int ( *pv );	/* pv == &v なので *pv = *(&v) == v と同じ */
  s_print_newline();

	  /*
			+-----------+
	 pv ->	|	0x04	| <= *pv
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

}

/*
 *
 */

void int_arg_func ( int v ) {

  s_print_string ( "直接 : " );
  s_print_int ( v );
  s_print_newline();

	  /*
			+-----------+
	   v =>	|	0x04	|
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */


  s_print_string ( "間接 : " );
  int_poiner_arg_func ( &v );		/* v のポインターをとりだし、それを値として渡す */

	  /*
			+-----------+
	  &v ->	|	0x04	|
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

}

/*
 *
 */

int main ( void ) {

  int_arg_func ( 0x01020304 );

	  /*
			+-----------+
	引数 =>	|	0x04	|
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */
 
  return 0;
}

/*
 *
 */

C:\usr\c\> sample-011
直接 : 16909060
間接 : 16909060
C:\usr\c\> 

sample-012

Download : sample-012.c ( SJIS 版 )

/*
 * 2011/06/24 sample-012.c
 */

/*
 *	
 */

#include <stdio.h>
#include "s_print.h"

/*
 *	文字型へのポインター ( char * 型 )
 */

void char_poiner_arg_func ( char *pv ) {

  s_print_hex ( (int) pv );
  s_print_string ( " : " );
  s_print_int ( *pv );

	  /*
			+-----------+
	pv ->	|	0x04	|	<= *pv : char * なので、 1 byte だけ参照される
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

  s_print_newline();

}

/*
 *	整数型へのポインター ( int * 型 )
 */

void int_poiner_arg_func ( int *pv ) {

  s_print_hex ( (int) pv );
  s_print_string ( " : " );
  s_print_int ( *pv );

	  /*
			+-----------+
	pv ->	|	0x04	|	<= *pv : int * なので、 4 byte 全体が参照される
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

  s_print_newline();

}

/*
 *
 */

void int_arg_func ( int v ) {

  s_print_string ( "直接             : " );
  s_print_int ( v );
  s_print_newline();

  s_print_string ( " int *: " );
  int_poiner_arg_func ( &v );				/* v のポインターを (int *) で渡す */

  s_print_string ( "char *: " );
  char_poiner_arg_func ( (char *)&v );		/* v のポインターを (char *) で渡す */

}

/*
 *
 */

int main ( void ) {

  int_arg_func ( 0x01020304 );

	  /*
			+-----------+
	引数 =>	|	0x04	|
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-012
直接             : 16909060
 int *: bfeab5a0 : 16909060
char *: bfeab5a0 : 4
C:\usr\c\> 

sample-013

Download : sample-013.c ( SJIS 版 )

/*
 * 2011/06/24 sample-013.c
 */

/*
 *	ポインターの型の違いによるアドレス値の違い
 */

#include <stdio.h>
#include "s_print.h"

/*
 *	文字型へのポインター ( char * 型 )
 */

void char_poiner_arg_func ( char *pv ) {

  /* *(pv+0)  */

  s_print_hex ( (int) pv + 0 );
  s_print_string ( " : " );
  s_print_int ( *(pv+0) );

	  /*
			+-----------+
	pv ->	|	0x04	|	<= *(pv + 0) : char * なので、 1 byte だけ参照される
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

  s_print_newline();

  /* *(pv+1) */

  s_print_hex ( (int) pv + 1 );
  s_print_string ( " : " );
  s_print_int ( *(pv+1) );

	  /*
			+-----------+
	pv+0 ->	|	0x04	|
			+-----------+
	pv+1 ->	|	0x03	|	<= *(pv + 1) : char * なので、 1 byte だけ参照される
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

  s_print_newline();

  /* *(pv+2) */

  s_print_hex ( (int) pv + 2 );
  s_print_string ( " : " );
  s_print_int ( *(pv+2) );

	  /*
			+-----------+
	pv+0 ->	|	0x04	|
			+-----------+
			|	0x03	|
			+-----------+
	pv+2 ->	|	0x02	|	<= *(pv + 2) : char * なので、 1 byte だけ参照される
			+-----------+
			|	0x01	|
			+-----------+
	  */

  s_print_newline();

  /* *(pv+3) */

  s_print_hex ( (int) pv + 3 );
  s_print_string ( " : " );
  s_print_int ( *(pv+3) );

	  /*
			+-----------+
	pv+0 ->	|	0x04	|
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
	pv+2 ->	|	0x01	|	<= *(pv + 2) : char * なので、 1 byte だけ参照される
			+-----------+
	  */

  s_print_newline();

}

/*
 *
 */

void int_arg_func ( int v ) {

  s_print_int ( v );
  s_print_newline();

  char_poiner_arg_func ( (char *)&v );		/* v のポインターを (char *) で渡す */

}

/*
 *
 */

int main ( void ) {

  int_arg_func ( 0x01020304 );

	  /*
			+-----------+
	引数 =>	|	0x04	|
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-013
16909060
bfb46560 : 4
bfb46561 : 3
bfb46562 : 2
bfb46563 : 1
C:\usr\c\> 

sample-014

Download : sample-014.c ( SJIS 版 )

/*
 * 2011/06/24 sample-014.c
 */

/*
 *	ポインターの型の違いによる参照領域の違い
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

void int_arg_func ( int v0, int v1 ) {

  s_print_string ( "sizeof ( int ) = " );
  s_print_int ( sizeof ( int ) );
  s_print_newline();

  s_print_string ( "元のポインター値 : " );
  s_print_hex ( (int) &v0 );
  s_print_newline();
  s_print_string ( "              値 : " );
  s_print_hex ( (int) *&v0 );
  s_print_newline();

  s_print_string ( "元のポインター値 : " );
  s_print_hex ( (int) (&v0+1) );
  s_print_newline();
  s_print_string ( "              値 : " );
  s_print_hex ( (int) *(&v0+1) );
  s_print_newline();

	  /*
			+-----------+
	v0 =>	|	0x04	|	<-	&v0 + 0
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+

			+-----------+
	v1 =>	|	0x08	|	<-	&v0 + 1
			+-----------+
			|	0x07	|
			+-----------+
			|	0x06	|
			+-----------+
			|	0x05	|
			+-----------+
	  */


  s_print_newline();

  s_print_string ( "sizeof ( char ) = " );
  s_print_int ( sizeof ( char ) );
  s_print_newline();

  s_print_string ( "元のポインター値 : " );
  s_print_hex ( (int)(char *)&v0 );
  s_print_newline();
  s_print_string ( "              値 : " );
  s_print_hex ( (int) *(char *)&v0 );
  s_print_newline();

  s_print_string ( "ポインター値 + 1 : " );
  s_print_hex ( (int) ((char *)&v0+1) );
  s_print_newline();
  s_print_string ( "              値 : " );
  s_print_hex ( (int) *((char *)&v0+1) );
  s_print_newline();

	  /*
			+-----------+
	&v0 ->	|	0x04	|	<-	(char *) &v0 + 0
			+-----------+
			|	0x03	|	<-	(char *) &v0 + 1
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+

			+-----------+
	v1 =>	|	0x08	|	<-	(char *) &v0 + 4
			+-----------+
			|	0x07	|	<-	(char *) &v0 + 5
			+-----------+
			|	0x06	|
			+-----------+
			|	0x05	|
			+-----------+
	  */

  s_print_string ( "ポインター値 + 4 : " );
  s_print_hex ( (int) ((char *)&v0+4) );
  s_print_newline();
  s_print_string ( "              値 : " );
  s_print_hex ( (int) *((char *)&v0+4) );
  s_print_newline();

  s_print_string ( "ポインター値 + 5 : " );
  s_print_hex ( (int) ((char *)&v0+5) );
  s_print_newline();
  s_print_string ( "              値 : " );
  s_print_hex ( (int) *((char *)&v0+5) );
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  int_arg_func ( 0x01020304, 0x05060708 );

	  /*
			+-----------+
	引数	|	0x04	|
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+

			+-----------+
			|	0x08	|
			+-----------+
			|	0x07	|
			+-----------+
			|	0x06	|
			+-----------+
			|	0x05	|
			+-----------+
	  */

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-014
sizeof ( int ) = 4
元のポインター値 : bfb79a90
              値 : 1020304
元のポインター値 : bfb79a94
              値 : 5060708

sizeof ( char ) = 1
元のポインター値 : bfb79a90
              値 : 4
ポインター値 + 1 : bfb79a91
              値 : 3
ポインター値 + 4 : bfb79a94
              値 : 8
ポインター値 + 5 : bfb79a95
              値 : 7
C:\usr\c\> 

sample-015

Download : sample-015.c ( SJIS 版 )

/*
 * 2011/06/24 sample-015.c
 */

/*
 *	ポインターにより、異なる型としてメモリセルを参照する
 */

#include <stdio.h>
#include "s_print.h"

/*
 *	文字型へのポインター値 ( char * )
 */

void char_poiner_arg_func ( char *pv ) {

  /* *(pv+0)  */

  s_print_hex ( (int) pv );
  s_print_string ( " : " );
  s_print_int ( pv[0] );
  s_print_string ( " " );
  s_print_int ( pv[1] );
  s_print_string ( " " );
  s_print_int ( pv[2] );
  s_print_string ( " " );
  s_print_int ( pv[3] );
  s_print_newline();

	  /*
			+-----------+
	pv ->	|	0x04	|	<= pv[0]
			+-----------+
			|	0x03	|	<= pv[1]
			+-----------+
			|	0x02	|	<= pv[2]
			+-----------+
			|	0x01	|	<= pv[3]
			+-----------+
	  */

}

/*
 *
 */

void int_arg_func ( int v ) {

  s_print_hex ( v );
  s_print_newline();

  char_poiner_arg_func ( (char *)&v );		/* v のポインターを (char *) で渡す */

	  /*
			+-----------+
	&v ->	|	0x04	|	<= v
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

}

/*
 *
 */

int main ( void ) {

  int_arg_func ( 0x01020304 );

	  /*
			+-----------+
			|	0x04	|	<= 引数
			+-----------+
			|	0x03	|
			+-----------+
			|	0x02	|
			+-----------+
			|	0x01	|
			+-----------+
	  */

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-015
1020304
bfdc92a0 : 4 3 2 1
C:\usr\c\> 

sample-016

Download : sample-016.c ( SJIS 版 )

/*
 * 2011/06/24 sample-016.c
 */

/*
 *	連続した引数を間接的に参照する
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

void print_data_while_positive ( int *pv ) {

  if ( *pv <= 0 ) {		/* 値が負だった */
		/* なにもすることはない */

	  /*
			+-----------+
			|	3		|
			+-----------+
			|	4		|
			+-----------+
			|	9		|
			+-----------+
			|	12		|
			+-----------+
			|	-1		|	<- pv : 最後を指している
			+-----------+
	  */


  } else {
	s_print_int ( *pv );					/* とりあえず、一個出力 */
	s_print_string ( " " );					/* 間に空白を入れて.. */
	print_data_while_positive ( pv + 1 );	/* 残りは再帰で */

	  /*
			+-----------+
			|	3		|
			+-----------+
	 *pv =>	|	4		|	<- pv : 途中を指している
			+-----------+
			|	9		|	<- pv + 1 : 残りを指している
			+-----------+
			|	12		|
			+-----------+
			|	-1		|
			+-----------+
	  */

  }

}

/*
 *
 */

void print_many_args ( int v, ... ) {		/* ... は、幾つ引数があるかわからないという事.. */

	print_data_while_positive ( &v );	/* 複数の引数の先頭のポインターを渡す */
	s_print_newline();

	  /*
			+-----------+
	  v =>	|	3		| <- &v
			+-----------+
			|	4		|
			+-----------+
			|	9		|
			+-----------+
			|	12		|
			+-----------+
			|	-1		|
			+-----------+
	  */

}

/*
 *
 */

int main ( void ) {

  print_many_args ( 3, 4, 9, 12, -1 );

	  /*
			+-----------+
	引数	|	3		|
			+-----------+
			|	4		|
			+-----------+
			|	9		|
			+-----------+
			|	12		|
			+-----------+
			|	-1		|
			+-----------+
	  */

  print_many_args ( 9, 2, 8, -2, 3, 5, -1 );

	  /*
			+-----------+
	引数	|	9		|
			+-----------+
			|	2		|
			+-----------+
			|	8		|
			+-----------+
			|	-2		|
			+-----------+
			|	3		|
			+-----------+
			|	5		|
			+-----------+
			|	-1		|
			+-----------+
	  */

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-016
3 4 9 12 
9 2 8 
C:\usr\c\> 

sample-017

Download : sample-017.c ( SJIS 版 )

/*
 * 2011/06/24 sample-017.c
 */

/*
 *	階乗の計算 ( 数学的な解釈 )
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

int factrial ( int n ) {

  if ( n == 1 ) {
	return 1;
  } else {
	return n * factrial ( n - 1 );
  }
}

/*
 *
 */

int main ( void ) {

  s_print_string ( "4! = " );
  s_print_int ( factrial ( 4 ) );
  s_print_newline();

/*
	数学的解釈
		f ( 4 )
			=> 4 * f ( 3 )
			=> 4 * ( 3 * f ( 2 ) )
			=> 4 * ( 3 * ( 2 * f ( 1 ) ) )
			=> 4 * ( 3 * ( 2 * 1 ) )
			=> 4 * ( 3 * 2 )
			=> 4 * 6
			=> 24
*/

  s_print_string ( "6! = " );
  s_print_int ( factrial ( 6 ) );
  s_print_newline();

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-017
4! = 24
6! = 720
C:\usr\c\> 

sample-018

Download : sample-018.c ( SJIS 版 )

/*
 * 2011/06/24 sample-018.c
 */

/*
 *	階乗の計算 ( メモリモデル的解釈 )
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

int factrial ( int n ) {

  s_print_string ( "メモリ : " );
  s_print_hex ( &n );
  s_print_string ( " -> " );
  s_print_int ( n );
  s_print_newline();

  if ( n == 1 ) {
	return 1;
  } else {
	return n * factrial ( n - 1 );
  }
}

/*
 *
 */

int main ( void ) {

  s_print_string ( "4! = " );
  s_print_int ( factrial ( 4 ) );
  s_print_newline();

/*
	メモリモデル
		f ( 4 )
			+---------------+
		n=>	|	4			|
			+---------------+

			=> f ( 3 )
			+---------------+
			|	4			|
			+---------------+
			|	?			|
			+---------------+
		n=>	|	3			|
			+---------------+

			=> f ( 2 )
			+---------------+
			|	4			|
			+---------------+
			|	?			|
			+---------------+
			|	3			|
			+---------------+
			|	?			|
			+---------------+
		n=>	|	2			|
			+---------------+

			=> f ( 1 )
			+---------------+
			|	4			|
			+---------------+
			|	?			|
			+---------------+
			|	3			|
			+---------------+
			|	?			|
			+---------------+
			|	2			|
			+---------------+
			|	?			|
			+---------------+
		n=>	|	1			|
			+---------------+

			=> return 1;
			=> 1

			+---------------+
			|	4			|
			+---------------+
			|	?			|
			+---------------+
			|	3			|
			+---------------+
			|	?			|
			+---------------+
		n=>	|	2			|
			+---------------+

			=> return n * 1;
				=> return 2 * 1;
				=> return 2;
			=> 2

			+---------------+
			|	4			|
			+---------------+
			|	?			|
			+---------------+
		n=>	|	3			|
			+---------------+

			=> return n * 2;
				=> return 3 * 2;
				=> return 6;
			=> 6

			+---------------+
		n=>	|	4			|
			+---------------+

			=> return n * 6;
				=> return 4 * 6;
				=> return 24;
			=> 24

*/

  s_print_string ( "6! = " );
  s_print_int ( factrial ( 6 ) );
  s_print_newline();

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-018
4! = メモリ : bf9d60c0 -> 4
メモリ : bf9d60a0 -> 3
メモリ : bf9d6080 -> 2
メモリ : bf9d6060 -> 1
24
6! = メモリ : bf9d60c0 -> 6
メモリ : bf9d60a0 -> 5
メモリ : bf9d6080 -> 4
メモリ : bf9d6060 -> 3
メモリ : bf9d6040 -> 2
メモリ : bf9d6020 -> 1
720
C:\usr\c\> 

sample-019

Download : sample-019.c ( SJIS 版 )

/*
 * 2011/06/24 sample-019.c
 */

/*
 *	ポインター型変数のポインター値
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	EOS	'\0'

/*
 *
 */

void print_many_string_args_while_empty ( char *ptr[] ) 
{
  if ( *ptr[0] == EOS ) {		/* 空文字列が与えられた */
	/* なにもする必要はない */

  /*
		+-----------+										+-----+
		|	*-------+------------------------------------->	| 'a' |
		+-----------+							+-----+		+-----+
		|	*-------+------------------------>	| '1' |		| 'b' |
		+-----------+				+-----+		+-----+		+-----+
		|	*-------+------------->	|	  |		| '2' |		| 'c' |
		+-----------+	+-----+		+ '日'+		+-----+		+-----+
ptr ->	|	*-------+->	| \0  |		|	  |		| '3' |		|'\0' |
		+-----------+	+-----+		+-----+		+-----+		+-----+
									|	  |		| '4' |
									+ '本'+		+-----+
									|	  |		| '5' |
									+-----+		+-----+
									|	  |		|'\0' |
									+ '語'+		+-----+
									|	  |
									+-----+
									|'\0' |
									+-----+
   */

  } else {						/* プリントするものがある */
	s_print_string ( ptr[0] );	/* 先頭の文字列を出力 */
	s_print_newline();
	print_many_string_args_while_empty ( ptr + 1 );	/* 残りを出力 */

  /*
		+-----------+										+-----+
ptr ->	|	*-------+------------------------------------->	| 'a' |	<- ptr[0]
		+-----------+							+-----+		+-----+
ptr+1->	|	*-------+------------------------>	| '1' |		| 'b' |
		+-----------+				+-----+		+-----+		+-----+
		|	*-------+------------->	|	  |		| '2' |		| 'c' |
		+-----------+	+-----+		+ '日'+		+-----+		+-----+
		|	*-------+->	| \0  |		|	  |		| '3' |		|'\0' |
		+-----------+	+-----+		+-----+		+-----+		+-----+
									|	  |		| '4' |
									+ '本'+		+-----+
									|	  |		| '5' |
									+-----+		+-----+
									|	  |		|'\0' |
									+ '語'+		+-----+
									|	  |
									+-----+
									|'\0' |
									+-----+
   */

  }
}

/*
 *
 */

void print_many_string_args ( char *top, ... ) {	/* 引数が沢山 */

  print_many_string_args_while_empty ( &top );

  /*
		+-----------+										+-----+
 top =>	|	*-------+------------------------------------->	| 'a' |
		+-----------+							+-----+		+-----+
		|	*-------+------------------------>	| '1' |		| 'b' |
		+-----------+				+-----+		+-----+		+-----+
		|	*-------+------------->	|	  |		| '2' |		| 'c' |
		+-----------+	+-----+		+ '日'+		+-----+		+-----+
		|	*-------+->	| \0  |		|	  |		| '3' |		|'\0' |
		+-----------+	+-----+		+-----+		+-----+		+-----+
									|	  |		| '4' |
									+ '本'+		+-----+
									|	  |		| '5' |
									+-----+		+-----+
									|	  |		|'\0' |
									+ '語'+		+-----+
									|	  |
									+-----+
									|'\0' |
									+-----+
   */

}

/*
 *
 */

int main ( void ) {

  print_many_string_args ( "abc", "12345", "日本語", "" );
  s_print_newline();

  /*
		+-----------+										+-----+
		|	*-------+------------------------------------->	| 'a' |
		+-----------+							+-----+		+-----+
		|	*-------+------------------------>	| '1' |		| 'b' |
		+-----------+				+-----+		+-----+		+-----+
		|	*-------+------------->	|	  |		| '2' |		| 'c' |
		+-----------+	+-----+		+ '日'+		+-----+		+-----+
		|	*-------+->	| \0  |		|	  |		| '3' |		|'\0' |
		+-----------+	+-----+		+-----+		+-----+		+-----+
									|	  |		| '4' |
									+ '本'+		+-----+
									|	  |		| '5' |
									+-----+		+-----+
									|	  |		|'\0' |
									+ '語'+		+-----+
									|	  |
									+-----+
									|'\0' |
									+-----+
   */

  print_many_string_args ( "1111", "bbb", "漢漢漢漢漢", "A", "" );
  s_print_newline();

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-019
abc
12345
日本語

1111
bbb
漢漢漢漢漢
A

C:\usr\c\> 

sample-020

Download : sample-020.c ( SJIS 版 )

/*
 * 2011/06/24 sample-020.c
 */

/*
 *	main 関数の引数
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	EOS	'\0'

/*
 *
 */

void print_many_string_args_while_empty ( int argc, char *argv[]  ) {

  if ( argc <= 0 ) {
	/* なにもする必要はない */
  } else {						/* プリントするものがある */
	s_print_string ( argv[0] );	/* 先頭の文字列を出力 */
	s_print_newline();
	print_many_string_args_while_empty ( argc - 1, argv + 1 );
  }
}

/*
 *
 */

int main ( int argc, char *argv[] ) {

  print_many_string_args_while_empty ( argc, argv );

  return 0;
}

/*
 *
 */

C:\usr\c\> sample-020
./a.out
C:\usr\c\> 

本日の課題

課題 20110624-01

Download : 20110624-01.c ( SJIS 版 )

/*
 * 20110624-1-QQQQ.c
 *	論理演算による符号なし 8 bit 二進数の足し算
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

#define	CHAR_BIT_SIZE	( 8 * sizeof ( char ) )		/* char 型の bit 長さ */

/*
 *
 */

void print_binary_digit ( unsigned int number, int digits ) {

  if ( digits <= 0 ) {
	/* 全ての桁を表示したのでやることなし */
  } else {
	print_binary_digit ( number / 2, digits - 1 );	/* とりあえず上位の桁を表示 */
	s_print_int ( number % 2 );						/* 最下位の桁一桁を表示 */
  }
}

/*
 *	論理値 ( 真/偽 ) を、1 bit の整数値で表現
 */

#define	TRUE	1		/* 「真」を 1 で表現 */
#define	FALSE	0		/* 「偽」を 0 で表現 */

#define Boolean	int		/* Boolean (真偽値) を int でコーディングする事にする */

/*
 *	print_boolean ( Boolean a )
 */

void print_boolean ( Boolean a )	/* 真偽値を表示 */
{

  if ( a == TRUE ) {		/* a が真ならば.. */
	s_print_string ( "True" );
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	s_print_string ( "False" );
  }
}

/*
 * boolean_and ( Boolean a, Boolean b ) == a & b
 */

int boolean_and ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真で、.. */
	if ( b == TRUE ) {		/* しかも b も真ならば.. */
	  return TRUE;			/* a and b は真 */
	} else {				/* b が真でないので ( 多分、偽だから.. ) */
	  return FALSE;			/* 偽を返す */
	}
  } else {					/* a が真でないので ( 多分、偽だから.. ) */
	return FALSE;			/* b を見るまでもなく偽を返す */
  }
}

/*
 * boolean_or ( Boolean a, Boolean b ) == a & b
 */

int boolean_or ( Boolean a, Boolean b ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return TRUE;			/* b と無関係に真 */
  } else if ( b == TRUE ) { /* a が偽でも b が真なら.. */
	return TRUE;			/* やっぱり真 */
  } else {					/* いずれでもなければ.. */
	return FALSE;			/* 偽となる */
  }
}

/*
 * boolean_not ( Boolean a ) == ~ a
 */

int boolean_not ( Boolean a ) {

  if ( a == TRUE ) {		/* もし、 a が真なら.. */
	return FALSE;			/* 偽となる */
  } else {					/* そうでなければ.. */
	return TRUE;			/* 真となる */
  }
}

/*
 * boolean_xor ( Boolean a, Boolean b ) == a ^ b
 */

int boolean_xor ( Boolean a, Boolean b ) {

  if ( a != b ) {			/* もし、 a と b が異れば */
	return TRUE;			/* 真となる */
  } else {					/* それ以外は */
	return FALSE;			/* 偽となる */
  }
}

/*
* calc_carray_with_carray ( Boolean a, Boolean b, Boolean carray )	三つの 1 \
    bit の数の繰り上がりの計算をする
 */

Boolean calc_carray_with_carray ( Boolean a, Boolean b, Boolean carray ) {

return boolean_or ( boolean_and ( a, b ), boolean_or ( boolean_and ( a, \
    carray ), boolean_and ( b, carray ) ) );
}

/*
* calc_1bit_with_carray ( Boolean a, Boolean b, Boolean carray )	三つの 1 bit \
    の数の一桁目を計算する
 */

Boolean calc_1bit_with_carray ( Boolean a, Boolean b, Boolean carray ) {

  return boolean_xor ( boolean_xor ( a, b ), carray );
}

/*
*	calc_nbit_adder_with_carray ( unsigned int aa, unsigned int bb, Boolean \
    carray, int digits )		繰り上がり付きの計算
 */

int calc_nbit_adder_with_carray ( unsigned int aa, unsigned int bb, Boolean \
    carray, int digits ) {

  if ( digits <= 0 ) {		/* 全ての桁を計算したので .. */

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

  } else {					/* そうでなければ.. */
    return

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

								/* 繰り上がり付きで、上位桁を計算したものを 2 倍にして : 再帰呼出 */
		 +

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

								/* 繰り上がり付きで、最下位桁の計算結果と加える */
  }
}

/*
 *	calc_nbit_adder ( int aa, int bb )
 */

int calc_nbit_adder ( int aa, int bb ) {

	return calc_nbit_adder_with_carray ( aa, bb, 0, CHAR_BIT_SIZE );
}

/*
 *	print_bin_and_dec ( int aa )
 */

void print_bin_and_dec ( int aa, int digits ) {

  print_binary_digit ( aa, digits );
  s_print_string ( " ( " );
  s_print_int ( aa );
  s_print_string ( " ) " );

}

/*
 *	print_nbit_adder ( int aa, int bb )		n bit の和の計算
 */

void print_nbit_adder ( int aa, int bb ) {

  print_bin_and_dec ( aa, CHAR_BIT_SIZE );
  s_print_string ( " + " );
  print_bin_and_dec ( bb, CHAR_BIT_SIZE );
  s_print_string ( " == " );
print_bin_and_dec ( calc_nbit_adder ( aa, bb ), CHAR_BIT_SIZE + 1 );	/* 結果は \
    1 bit 長くなる可能性がある.. */
  s_print_newline();

}

/*
 *
 */

int main ( void ) {

  print_nbit_adder ( 0, 0 );
  print_nbit_adder ( 1, 0 );
  print_nbit_adder ( 0, 1 );
  print_nbit_adder ( 1, 1 );

  print_nbit_adder ( 3, 5 );
  print_nbit_adder ( 10, 20 );
  print_nbit_adder ( 11, 21 );

  return 0;
}

/*
 *
 */

C:\usr\c\> 20110624-01
00000000 ( 0 )  + 00000000 ( 0 )  == 000000000 ( 0 ) 
00000001 ( 1 )  + 00000000 ( 0 )  == 000000001 ( 1 ) 
00000000 ( 0 )  + 00000001 ( 1 )  == 000000001 ( 1 ) 
00000001 ( 1 )  + 00000001 ( 1 )  == 000000010 ( 2 ) 
00000011 ( 3 )  + 00000101 ( 5 )  == 000001000 ( 8 ) 
00001010 ( 10 )  + 00010100 ( 20 )  == 000011110 ( 30 ) 
00001011 ( 11 )  + 00010101 ( 21 )  == 000100000 ( 32 ) 
C:\usr\c\> 

課題 20110624-02

Download : 20110624-02.c ( SJIS 版 )

/*
 * 20110624-2-QQQQ.c
 *	
 */

/*
 *	連続した引数の和を計算する
 */

#include <stdio.h>
#include "s_print.h"

/*
 *
 */

int sum_data_while_positive ( int *pv ) {

  if ( *pv <= 0 ) {		/* 値が負だった */
		/* なにも足す事はない */

	  return 0;			/* 0 を返す */

	  /*
			+-----------+
			|	3		|
			+-----------+
			|	4		|
			+-----------+
			|	9		|
			+-----------+
			|	12		|
			+-----------+
			|	-1		|	<- pv : 最後を指している
			+-----------+
	  */

  } else {

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

		/* 現在の値と、残りの和を加えればよい */

	  /*
			+-----------+
			|	3		|
			+-----------+
	 *pv =>	|	4		|	<- pv : 途中を指している
			+-----------+
			|	9		|	<- pv + 1 : 残りを指している
			+-----------+
			|	12		|
			+-----------+
			|	-1		|
			+-----------+
	  */

  }

}

/*
 *
 */

int sum_many_args ( int v, ... ) {		/* ... は、幾つ引数があるかわからないという事.. */

	return sum_data_while_positive ( &v );	/* 複数の引数の先頭のポインターを渡す */

	  /*
			+-----------+
	  v =>	|	3		| <- &v
			+-----------+
			|	4		|
			+-----------+
			|	9		|
			+-----------+
			|	12		|
			+-----------+
			|	-1		|
			+-----------+
	  */

}

/*
 *
 */

int main ( void ) {

  s_print_int ( sum_many_args ( 3, 4, 9, 12, -1 ) );
  s_print_newline();

	  /*
			+-----------+
	引数	|	3		|
			+-----------+
			|	4		|
			+-----------+
			|	9		|
			+-----------+
			|	12		|
			+-----------+
			|	-1		|
			+-----------+
	  */

  s_print_int ( sum_many_args ( 9, 2, 8, -2, 3, 5, -1 ) );
  s_print_newline();

	  /*
			+-----------+
	引数	|	9		|
			+-----------+
			|	2		|
			+-----------+
			|	8		|
			+-----------+
			|	-2		|
			+-----------+
			|	3		|
			+-----------+
			|	5		|
			+-----------+
			|	-1		|
			+-----------+
	  */

  return 0;
}

/*
 *
 */

C:\usr\c\> 20110624-02
28
19
C:\usr\c\> 

Links

• 論理回路
• 論理回路
• 論理回路 （logic device）
• ビット 【bit】
• ビット
• JIS漢字コード （情報交換用漢字符号 JIS X 0208 1990年）
• 二進法
• 2進数、16進数と10進数
• Ｃ言語編　第１０章　変数のサイズ
• 2の補数
• 32 bit 整数の内部表現
• 加算器
• オーバーフロー
• オーバーフロー 【overflow】（桁あふれ）
• 浮動小数点数
• 演算誤差の正体
• 【Ｃ言語講座】演算子一覧表
• C言語の演算子について
• 第5章. 演算子