プログラム応用の最近のブログ記事

安全な入力とdefineマクロ

ファイル処理の最後の説明で、バッファ・オーバーフローと、安全な入力について説明。

安全な入力

一般的なC言語での文字列入力のプログラムは、以下の様なものがテキストにも書かれている。

// memory
// [局所変数str][戻り番地][..........]
void foo() {
   char str[ 10 ] ;
   scanf( "%s" , str ) ;
}

バッファオーバーフロー

しかし、こういった処理は極めて危険である。 入力の際に、10文字以上のデータが入力された場合、 一般的な処理系では、str[] の配列の近辺に 「関数foo()の実行後に戻る処理の番地」が格納されている場合が多く、 文字列をはみ出るような入力があった場合、処理番地を書き換えられる可能性がある。 悪意のあるプログラマーは、はみ出す領域に、戻り番地を書き換えるデータと、悪意のある処理を 書くことで、想定外の処理を動かすかもしれない。 このテクニックをバッファオーバーフローと呼ぶ。

このため、最大文字制限の機能を使い、以下のように記述すべきである。

char str[ 10 ] ;
scanf( "%9s" , str ) ;

しかし、scanf() には、空白を読み飛ばす機能により「入力が無い場合...」といった 処理が書きにくい、%d入力で実数の"."や文字列を間違って入力したときの処理などの 問題があって、scanf() 単体で複雑な入力に対応することは極めて難しい。

fgets() + sscanf()

このような場合によく使われるのが、fgets()とsscanf()である。

fgets() は、文字配列に1行分のデータ(行末文字"¥n"まで)を、文字配列に読み込む関数である。 また、sscanf() は、文字配列のデータから、scanf() と同じようにデータを読み込む。

FILE* fp ;
if ( (fp = fopen( "data.txt" , "rt" )) != NULL ) {
   char buff[ 100 ] ;
   while( fgets( buff , sizeof( buff ) , fp ) != NULL ) {
      int x ;
      double y ;
      char z[100] ;

      if ( sscanf( buff , "%d%lf%s" , &x , &y , z ) != 3 )
         break ;
      // x , y , z を使った処理
   }
   fclose( fp ) ;
}

fgets() は、第一引数に、読み込み先の配列アドレス、第2引数に最大読み込みバイト数、第3引数に 読み元のファイルを指定する。文字配列への読み込み時には、第2引数のサイズを超えて 読み込むことはしないので、バッファオーバフローの心配はない。 また、入力データが無い場合には、NULL を返す。
sizeof()は、引数部分の変数のバイト数を返す演算子。

sscanf() は、データの入力が、第一引数の文字列から読み込む以外は、 scanf(),fscanf() と同じ使い方。

注意:fgets では、入力が最大バイト数以下の場合、行末文字まで読み込む。

Tips: 入力が無かったら(空行なら)、標準入力(通常キーボード入力)なら

char buff[ 1024 ] ;
while( fgets( buff , sizeof( buff ) , stdin ) != NULL ) ) {
   // stdin は、標準入力(通常キーボード)
   if ( buff[ 0 ] == '¥n' ) {
      // 入力が空行だった場合
   }
}

fscanf()にfprintfがあるように、sscanfに対してsprintfもある。

char buff[ 1024 ] ;
sprintf( buff , "%d %5.1lf %s" , 12 , 34.5 , "abc" ) ;
// buff = "12  34.5 abc"となる。

#defineマクロ

scanfで"%d"で数字を入力する際に、文字を入力されると、あとの処理が書きにくい場合が多い。 この場合、fgetsで入力し入力データが正しい文字を使っているかチェックしてから、 sscanf()を使うなどの対処をとることが多い。 ここで、#define マクロを使ってみる

#include <stdio.h>
#define isdigit(C) ((C)>='0' && (C)<='9')

void main() {
   char buff[ 1024 ] ;
   while( fgets( buff , sizeof( buff ) , stdin ) != NULL ) {
      char* pc ;
      for( pc = buff ; *pc != '¥0' && isdigit( *pc ) ; pc++ )
         /*nothing*/ ;
      if ( *pc == '¥n' || *pc == '¥0' ) {
         int x ;
         sscanf( buff , "%d" , &x ) ; 
      }
   }
}

#define は、通常プログラム中の定数を分かりやすく使う場合に、使われる。

#define PI 3.14159265

ただし、#で始まる行は、C言語によって特殊で、C言語の解析の前に「プリプロセッサ」 でプログラムの内容を書き換える機能。

C言語のプログラムが機械語になるまで:

 C言語(#行を含む)
  ↓ プリプロセッサ
 C言語(#行なし)
  ↓ コンパイル
 中間コード(printfなどの標準関数などが未解決)
  ↓
 リンク処理ライブラリ(標準関数などの中間コードをまとめたもの)
  ↓
 機械語

#define マクロでは、isdigit() の引数? C が、呼び出し部の *pc となり、 isdigit( *pc ) の部分は、以下のように書き換えられる。

#define isdigit(C) ((C)>='0' && (C)<='9')
isdigit(*pc)
  ↓ C ← *pc
((*pc)>='0' && (*pc)<='9')

ただし、#defineマクロは、プログラムのコンパイル前に、文字列として書き換えを行う。

// 例1
#define begin {
#define end }
void main() // まるでPASCALのような記述(^_^;
begin
   printf( "Hello¥n" ) ;
end         // 正しく動くよ

// 例2
#define ADD(X,Y) X + Y
#define MUL(X,Y) X * Y
void main() {
   printf( "%d" , MUL( 3 , ADD( 4 , 5 ) ) ) ;
}
// 3 * 4 + 5 に書き換えられるので、17になる。
// 3 * (4+5) の27にはならない。
// 普通の関数のように27の結果が欲しいなら、
// #define ADD(X,Y) ((X)+(Y))
// #define MUL(X,Y) ((X)*(Y))
// と書くべき。

開いた関数と閉じた関数

#defineマクロは、定義しておいた命令への書き換えなので、関数と同じように思うかもしれない。 ただし、機械語を生成する処理の前に書き換えるので、#define マクロで書き換えられる処理が 長い場合は、生成される機械語が大きくなる場合がある。 一方で、#defineマクロを使うと引数の受け渡しが無いので、 isdigit()のような簡単な処理の場合、 生成される機械語の処理が少し速い。

// 開いた関数FOO
#define FOO(X) Xを使った処理
void main() {
   int x ;
   FOO(x) ;  // xを使った処理
   FOO(x) ;  // xを使った処理
   // FOOの中身が長い場合、FOOの機械語が2個作られる。
}

// 閉じた関数foo
int foo(int z) {
   zを使った処理
   :
   :
}
void main() {
   int x ;
   foo(x) ; // z←x,fooを呼び出し
   foo(x) ; // z←x,fooを呼び出し
   // fooの機械語は1個だけ,引数の受け渡し処理が2個
}
#defineマクロのADD,MULの優先順位の問題が、"醜い"と思う人は、 C++で新しく導入された、"inline"関数を勉強すること。 #defineマクロを使わずに、開いた関数を簡単に記述できる。

絶対PATH,相対PATHの演習

絶対PATH,相対PATHの理解のため、コマンドラインを用いた演習も行う。

ファイル関連コマンドの基本

(( まずは cmd.exe の起動 ))
メニュー検索より、"cmd.exe" を探して起動

(( ファイル操作命令の基礎 ))
dir PATH  ディレクトリの一覧を表示
 例:dir C:¥Windows

type PATH ファイルの内容を表示
 例:type Z:¥sample¥sample.c

mkdir PATH ディレクトリを作成
 例:mkdir Z:¥foo

rmdir PATH ディレクトリを削除
 例:rmdir Z:¥foo

echo "abc" > Z:¥sample¥data.txt テキストファイルに出力

演習

(( 絶対PATH ))
Z:
dir ¥
mkdir ¥fukui
echo "fukui" > ¥fukui¥fukui.txt
type ¥fukui¥fukui.txt
mkdir ¥fukui¥sabae
echo "sabae" > ¥fukui¥sabae¥sabae.txt
dir ¥fukui¥sabae
type ¥fukui¥sabae¥sabae.txt
(( 相対PATH ))
cd ¥fukui¥sabae
dir .
dir ..
type sabae.txt
type ..¥fukui.txt
dir ..¥..

ファイル入出力

今日は、ファイル入出力のプログラム演習。

ファイル入出力

 // 基礎的なファイル入力
 #include <stdio.h>

 void main() {
    FILE* fp ;
    if ( (fp = fopen( "data.txt" , "rt" )) != NULL ) {
       char name[ 100 ] ;
       int age ;
       while( fscanf( fp , "%s%d" , name , &age ) == 2 ) {
          printf( "%s %d\n" , name , age ) ;
       }
       fclose( fp ) ;
    }
 }
 // 入力したデータから条件を満たすデータだけを出力
 #include <stdio.h>

 void main() {
    FILE* fp_in ;
    FILE* fp_out ;
    if ( (fp_in = fopen( "in.txt" , "rt" )) != NULL ) {
       if ( (fp_out = fopen( "out.txt" , "wt" )) != NULL ) {
          char name[ 100 ] ;
          int  age ;
          while( fscanf( fp_in , "%s%d" , name , &age ) == 2 ) {
             if ( age >= 18 )
                fprintf( fp_out , "%s %d\n" , name , age ) ;
          }
          fclose( fp_out ) ;
       }
       fclose( fp_in ) ;
    }
 }

テキストモードとバイナリモード

前述プログラムでは、fopen のファイルモードで、"rt" , "wt" のように 文字"t"をつけている。これは、OSによる行末文字の取り扱いの トラブルを防ぐためのもの。

OSの成り立ちの違いで、Windows と Unix では、行末文字の取り扱い方法 が違う。

Windows では、次の行の先頭に移動するには、"\r"(キャリッジリターン)と "\n"(ラインフィード)が必要となる。

一方、Unix では、次の行の先頭に移動するには、"\n"(ラインフィード)だけ でいい。

この違いがあるため、Unixで開発されたC言語で書いたプログラムを Windows で動かそうとすると、

                       // Unix    Windows
 printf( "Hello\n" ) ; // Hello   Hello
 printf( "World\n" ) ; // World        World

と異なる表示になってしまう。これでは、WindowsでC言語を書く場合は、 printf( "Hello\r\n" ) といった書き換えが必要になってしまう。

これを防ぐために、fopen で "...t" 書くことで「テキストモード」に 指定すると Windows で printf( "\n" ) を出力すれば、 "\r\n" に変換して出力してくれる。入力時にも同様に、"\r\n" があると、 "\n" に変換してくれる。

絶対PATHと相対PATH

前述のプログラムで、fopen( "data.txt" , "rt" ) と指定すると、 プログラムの保存しているディレクトリと同じ場所から、"data.txt" を 探そうとする。(相対PATH)

しかし、別のディレクトリにあるデータを読む場合には、 場所を明記するために、Z:\directory\data.txt のように、 ルートディレクトリからの場所(Windowsではドライブ名付きで)を 指定する。(絶対PATH)

ただし、Windows でのディレクトリ区切り文字 '\' は、C言語の文字列内では、 特殊文字を指定する時に使われる。このため、文字列内では \\ の様に 書く必要がある。

 fp = fopen( "Z:\\directory\\data.txt" , "rt" ) ;

この場合、"\\"と2重で書くことで、Unix と Windows のプログラムの 書き換えが必要となるのを防ぐため、上例は、Unixのディレクトリ区切り文字"/"を使って、以下のように書いても良い。

 fp = fopen( "Z:/directory/data.txt" , "rt" ) ; 

プログラミング応用のグラフィックスを用いた演習では、 簡単な設定で使えるようにということで GrWin を使用している。 しかし、昨年度まで利用していたものから、正式バージョン GrWin 1.0 となった際に、 ライセンスキーが必要となった。

GrWinのライセンスキーの設定

総合情報処理センターでは、複数端末の教育利用ライセンスを取得し、 そのキーの情報が端末に保存されています。 プログラムを走らせる場合は、以下のようなコードにてコンパイルして下さい。

#include <GrWin.h>

#include "C:\Program Files\GrWin\gwkey.c"

int main(){
	GWinit();
	GWopen(0);
	GWindow(-1,-1,1,1);
	GWline(-1,-1,1,1);
	return 0;
}

// 以下の C:¥Program Files¥GrWin¥gwkey.c" は、保存済み // /* gwkey.c * * Copyright (C) 1998 - 2014 TAMARIBUCHI, Tsuguhiro * * WWW: http://spdg1.sci.shizuoka.ac.jp/grwin/ja-jp/ * ********************************************** * GrWin Version 1.1.0 用のキー・ファイルです * * このファイルを編集しないでください * ********************************************** */ char GW_key[] = "ライセンスキーの値";

自宅で GrWinを使って演習を行いたい場合は、必要な GrWinサーバインストーラ(非商用)GrWinライブラリインストーラ、をダウンロード&インストールし、 個人用ライセンス取得ページにて、ライセンスを発行し送られてきたキーを、上記 "C:¥Program Files¥GrWin¥gwkey.c" の GW_key[] の文字配列に記載してください。

IchigoJamでモンテカルロ法

IchigoJam で真面目にπを計算させるというのを、 松田さんがBlogに書かれていて、面白かったので、 追加でちょいとお遊び。

1511111501_477x273.png

元プログラムは、1000回ループのモンテカルロ法で、 精度をあげるには...というお話なんだけど、 1000回ループを10倍で....なら、100×100のマス目で x^2 + y^2 < 100^2 の判定と同じということで、 超簡単なプログラムで答えを比べてみた。

1511111501_314x426.png

たった、4行のプログラムだけど、精度をあげようと 思うと奥が深いかな。

出張の都合により、今日は授業を入替え、3年の授業。
構造体の理解については、明日の授業で演習を行う。今日は、振替えで演習室も使えないので、 普通の講義。

ビットフィールド

例えば、生年月日を記憶する場合、構造体を使えば以下のように宣言できるが、 int型(32bit=4byte)であれば、12byteを要する。

struct YMD {
    int  year ;
    int  month ;
    int  day ;
} ;

しかし、生年月日の比較などをする場合であれば、 年月日を10進数の桁に合わせて、日付を 20151109 といった数値で表すことも多い。 この場合であれば、int 型 2^31-1 = 2,000,000,000 にも収まる。 プログラムも解りやすくするのであれば、以下の様な補助関数を準備すれば良い。

int ymd10_year( int ymd ) {
    return ymd / 10000 ;
}
int ymd10_month( int ymd ) {
    return (ymd / 100) % 100 ;
}
int ymd10_day( int ymd ) {
    return ymd % 100 ;
}

しかし、このプログラムでは、日の1〜31までの数字のために、0〜99の10進2桁を使う。 月の1〜12のために0〜99の10進2桁を使う。 また、各桁を抜き出すために、除算を使うため処理も手間がかかる。

そこで、年月日を2進数の桁の組合せで保存することを考える。こうすれば、2進数のビットシフト命令で機械語では扱いやすくなる。

// 年(12bit),月(4bit),日(5bit) = Y,YYYY,YYYY,YYYM,MMMD,DDDD
int ymd2( int y , int m , int d ) {
    return (y << 9) | (m << 5) | d ;
}
int ymd2_year ( int ymd ) {
    return ymd >> 9 ;
}
int ymd2_month( int ymd ) {
    return (ymd >> 5) & 0xF ;
}
int ymd2 _day( int ymd ) {
    return ymd & 0x1F ;
}

しかし、この方法でデータを扱うと、月の値を1つ増やすといった処理を書こうと思うと、2進数の扱いに慣れていないと プログラムも間違いやすい。

int ymd = ymd2( 2015 , 11 , 9 ) ;
// ymd の月を12月に変更したい。
ymd = (ymd  & 0x1FFE1F) | (12 << 5) ;

このような処理のために、ビットフィールドを使用する。使い方は、構造体の要素の宣言の後ろに、": bit数"をかけばいい。 こうすれば、構造体の要素の参照の式をかけば、必要に応じて2進数を使った機械語命令をコンパイラが書いてくれる。

struct YMD {
    unsigned int  year  : 12 ;
    unsigned int  month : 4 ;
    unsigned int  day   : 5 ;
} ;

共用体

構造体と同じような文法の一つに共用体がある。 構造体では、異なる型の各要素のメモリの領域を準備するが、共用体では全要素が同じ場所を使う。 このため、どれか1つの値を覚えるだけでいい場合に使う。

union int_str4 {
    int  data ;
    char str[4] ;
} ;
union int_str4  a[4] ;

a[0].data = 1234 ;
strcpy( a[1].str , "ABC" ) ;
a[2].data = 2345 ;
strcpy( a[3].str , "BCD" ) ;
printf( "%d¥n" , sizeof( a ) ) ; // 4byte×4 = 16

この異なる型を同じ場所に覚えるための文法は、最近のオブジェクト指向のプログラム言語では、仮想関数という考え方 が利用できるので、あまり利用することは少なくなっている。

列挙型

プログラムの中で週のような情報を覚える時、日付の処理を考えると、 日=0,月=1,火=2,水=3,木=4,金=5,土=6 といった割り当てをすることも多い。 しかし、水曜の処理だったら...という時に、if ( week == 3 ) という書き方では、分かりにくい。

int wd = 1 ; // 月初めが月曜の場合...
int day ;
for( day = 1 ; day <= 31 ; day++ , wd = (wd + 1) % 7 ) {
    if ( wd == 3 ) {
        水曜日の処理...
    }
}
// マジックナンバーを使わない場合
#define SUN 0
#define MON 1
#define TUE 2
#define WED 3
  : (略)

int wd = MON ; // 月初めが月曜の場合...
int day ;
for( day = 1 ; day <= 31 ; day++ , wd = (wd + 1) % 7 ) {
    if ( wd == WED ) {
        水曜日の処理...
    }
}

上のプログラムの後半のマジックナンバーを使わない例であれば、プログラムの意味も解りやすくなる。 しかし、#define を7つも書き並べるのは面倒だし、対応する数値を1つづつ増やしながら書くのは、 間違って修正するかもしれない。 こういう場合には、列挙型を用いる。

enum Week {
   SUN , MON , TUE , WED , THR , FRI , SAT
} ;
enum Week wd = MON ;
int day ;
for( day = 1 ; day <= 31 ; day++ ) {
    if ( wd == WED ) {
        水曜日の処理...
    }
    // wd 型は int ではないので、週番号を増やすのはちょっと面倒
    wd = (enum Week)( ( (int) wd + 1 ) % 7 ) ;
}

構造体のワード境界

今日は、構造体を使ったプログラミングの演習。 単純な演習だけでは、来週に研修旅行を予定している3年は授業の遅れも心配なので、 前半にワード境界の話をする。

ワード境界

struct Data {
    char name[3] ;
    int  point ;
} ;
struct Data array[3] ;

// 構造体の大きさは何バイト?
printf( "%d\n" , sizeof( struct Data ) ) ;
printf( "%d\n" , sizeof( array ) ) ;

簡単なデータのバイト数の知識だけであれば、Dataの大きさは、3byte+4byteの 7byteと思うかもしれない。しかし、この考えだと、array の配列は、メモリ上に以下に並ぶと思うであろう。

n1,n1,n1が、array[1].nameの3byteをあらわすとする。
n0,n0,n0,p0,p0,p0,p0,n1,n1,n1,p1,p1,p1,p1,n2,n2,n2,p2,p2,p2,p2

しかし、最近のコンピュータでは、CPUクロック2GHz,メモリクロック1GHzといった速度で、 メモリの速度はCPUに比べて遅い。このため、CPUがメモリのデータを読み出す際は、 複数のbyte数を一括して読み込む。このデータの単位は32bitコンピュータであれば、 4byte単位であったりする。

ワード境界を考えない構造体要素の配置の場合
0行目:n0,n0,n0,p0,
1行目:p0,p0,p0,n1,
2行目:n1,n1,p1,p1,
3行目:p1,p1,n2,n2,
4行目:n2,p2,p2,p2,
5行目:p2,--,--,--,

この場合、array[1].pointを読み出そうとすると2行目と3行目の2回にわけて データを読み込むことになり、プログラムの速度が落ちてしまう。

このため、構造体の要素をメモリに保存する場合、4byte毎の「ワード境界」を またがってデータを配置しないようにするのが普通である。こういう メモリへの配置を「ワードアライメント」という。

ワード境界を考え、途中に空き(xx)を配置した例
0行目:n0,n0,n0,xx,
1行目:p0,p0,p0,p0,
2行目:n1,n1,n1,xx,
3行目:p1,p1,p1,p1,
4行目:n2,n2,n2,xx,
5行目:p2,p2,p2,p2

ということで、sizeof( struct Data ) は、8byteとなるのが普通である。 ただし、処理速度を犠牲にしてメモリ量を節約する必要がある場合には、 "#pragma ...."といったプリプロセッサ命令で、隙間を詰めることもできる。

「ワード」とは、8bit = 1byte より大きいデータ単位で、16bitであったり、32bitであったりする。 機械語でプログラムを記述する際には、以下のように区別することが多い。
16bit = 2byte = ワード(WORD),対応する型:short int
32bit = 4byte = ダブルワード(DWORD)、対応する型:int,float
64bit = 8byte = QWORD、対応する型:double

一緒に、来週のプログラミング応用の資料書いちゃえ。

構造体の参照渡し

構造体のデータを関数の呼び出しで記述する場合には、参照渡しを利用する。

struct Person {
    char name[ 20 ] ;
    int  age ;
} ;
void print( struct Person* p ) {
    printf( "%s %d¥n" , p->name , p->age ) ;
}
void main() {
    struct Person saitoh ;
    strcpy( saitoh.name , "t-saitoh" ) ;
    saitoh.age = 50 ;

    print( &saitoh ) ;
}

このようなプログラムの書き方をすると、「データ saitoh に、print() せよ...」 といった処理を記述したようになる。 これを発展して、データ saitoh に、print という命令をするイメージにも見える。

この考え方を、そのままプログラムに反映させ、Personというデータは、 名前と年齢、データを表示するprintは...といったように、 データ構造と、そのデータ構造への処理をペアで記述すると分かりやすい。

オブジェクト指向の導入

オブジェクト指向では、データ構造とその命令を合わせたものをクラス(class)と呼ぶ。 また、データ(class)への命令は、メソッド(method)と呼ぶ。

class Person {
private:
    char name[ 20 ] ;
    int  age ;
public:
    Person( char s[] , int a ) {
        strcpy( name , s ) ;
        age = a ;
    }
    int scan() {
        return scan( "%s %d" , name , &age ) ;
    }
    void print() {
        printf( "%s %d¥n" , name , age ) ;
    }
} ;
void main() {
    Person saitoh( "t-saitoh" , 50 ) ;
    saitoh.print() ;

    Person table[ 50 ] ;
    for( int i = 0 ; i < 50 ; i++ ) {
        if ( table[ i ].scan() != 2 )
            break ;
        table[ i ].print() ;
    }
}

プログラミング応用の後期では、構造体とコンピュータグラフィックスの基礎を扱う予定。 CGの基礎でも、X座標,Y座標...をひと塊の構造体で表現という意味では、構造体の延長として授業を進める予定。

構造体

上記資料を元に説明。 最初に構造体が無かったら、名前・国語・算数・理科の1クラス分のデータをどう表現しますか?

// まずは基本の宣言
char name[ 50 ][ 20 ] ;
int  kokugo[ 50 ] ;
int  sansu[ 50 ] ;
int  rika[ 50 ] ;

// もしクラスが最初20人だったら、20→50に変更する際に、
// 文字列長の20も書きなおしちゃうかも。
// 50とか20とかマジックナンバーは使わないほうがいい。
#define SIZE 50
#define LEN 20
char name[ SIZE ][ LEN ] ;
int  kokugo[ SIZE ] ;
    :
// 2クラス分のデータ(例えばEI科とE科)を保存したかったら?
// case-1(配列2倍にしちゃえ)
char name[ 100 ][ 20 ] ;  // どこからがEI科?
int  kokugo[ 100 ] ;
    :
// case-2(2次元配列にしちゃえ)
char name[ 2 ][ 50 ][ 20 ] ; // 0,1どっちがEI科?
int  kokugo[ 2 ][ 50 ] ;
    :
// case-3(目的に応じた名前の変数を作っちゃえ)
char ei_name[ 50 ][ 20 ] ; // EI科は一目瞭然
int  ei_kokugo[ 50 ] ;     // だけど変数名が違うから
    :                      // 処理を2度書き
char ee_name[ 50 ][ 20 ] ;
int  ee_kokugo[ 50 ] ;
    :

このような問題に対応するために構造体を用いる。

struct Person {  // Personが構造体名(タグ名)
    char name[ 20 ] ;
    int  kokugo ;
    int  sansu ;
    int  rika ;
} ;
struct Person saitoh ;
struct Person ei[ 50 ] , ee[ 40 ] ;
strcpy( saitoh.name , "t-saitoh" ) ;
saitoh.kokugo = 100 ;
ei[ 0 ].sansu = 80 ;
ee[ 1 ].rika = 75 ;

授業では、構造体の初期化、入れ子の話をする。詳細は配布資料参照。

途中で、C言語の歴史として、unix開発時に、BCPL→B言語→C言語(K&R)→ANSI-C→...C++→D言語 といった雑談も説明。

入れ子の話では、 for(...) { for(...) { } } のような、処理の入れ子(処理の構造化)と、 構造体の入れ子(データの構造化)の話から、構造化プログラミング(structured programming)といった話も紹介する。

先日の数値の範囲の説明で、浮動小数点型(float,double)などについても説明を行う。

16bitコンピュータの時代...

簡単な桁あふれの事例として、古いコンピュータ16bitの時代の事例。

// int は16bitとする。
// パソコン画面上の2点の距離を計算したい。
int x1 , y1 ;
int x2 , y2 ;
int r = (int) sqrt( (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) ) ;

このプログラムは、負の値の平方根を求めた...というエラーメッセージで止まってしまう。

これは、座標が200ドット離れていれば、2乗の和を求めた段階で、40000となるが、 16bit 符号付き整数であれば、最大数が32767 なので桁あふれして、負の数として扱われている。

2038年問題

次に、20XX年問題の説明。 2000年問題とは、古いプログラムで西暦末尾2桁で年を扱っていたプログラムが誤動作を 起こす可能性の問題。

同じように数値の範囲が原因となるものとして、2038年問題を紹介する。 OS unix では、時間を1970年からの経過秒数で表す。 この時、32bit(符号付きint型)であれば、2^31-1が扱える最大数であり、 (2^31-1) / (3600*24*365.22)を求めると、約68年となる。 つまり、32bit int であった場合は、2038年以降は桁あふれで時間を正しく扱えなくなる可能性がある。

しかし、計算の途中の段階で桁あふれして動かない事例はある。 以下の事例は、2004年に実際に発生したトラブルと同様の簡単なコードである。

// intは32bitとする
// 2つの時間の中央時間を計算するコード
int t1 , t2 ;
int tm = (t1 + t2) / 2 ;

32bitの時間情報では、2004年以降は、 t1,t2の上位ビットが01XX......となっているため、 t1+t2 を計算すると最上位ビット(符号ビット)が1となり この後の計算は、負の値として扱われた。

上記のコードは、次のように記述するか、64bit化されたtime_t型で 記述すべきである。

// 32bitでも動く
int tm = t1 + (t2 - t1) / 2 ;

// 64bitのtime_t型
time_t t1 , t2 ;
time_t tm = (t1 + t2) / 2 ; // △
time_t tm = t1 + difftime( t2 , t1 ) / 2 ; // ◎

248日問題

丁度ニュースで、「ボーイング787が248日以上連続稼働すると、電源停止で制御不能となる」というネタが 紹介されている。点検などがあるから、実際はあり得ない状況だとは思えるが、 これもint型の桁あふれが原因らしい。 あり得ないとはいえ、フライバイワイヤ(操縦桿を電気信号で制御)の最新機は、電源が落ちれば即墜落。 これは、10msec単位で、OSの経過時間をint型(32bit)で制御しているのが 原因らしい。10msec*(2^31)=248日で桁あふれが発生して、電源稼働経過時間を誤認するらしい。 これと同様の事象は、Windows Xpなどが出た頃にも発生している。 787ほど深刻な墜落はないにしても、サーバ機なら248日稼働ぐらいはよくある話。

浮動小数点型と演算順位の問題

float型やdouble型は、浮動小数点で実数の小さな値から大きな値まで扱える。


しかしながら、プログラム中の式の順序によっては、注意が必要となる。

int a[ 5 ] = { 10 , 10 , 10 , 10 , 11 } ;
int s = 0 , size = 5 ;
for( int i = 0 ; i < size ; i++ )
    s += a[ i ] ;

printf( "%lf¥n" , s / size ) ;
// × %lf はdouble型、s/size はint型で異常な値が表示される。

printf( "%lf¥n" , (double)( s / size ) ) ;
// × s/sizeはint型で、小数点以下が求まらない。

printf( "%lf¥n" , (double)s / (double)size ) ;
// ◎
#define PI 3.141592
double x ;
for( x = 0.0 ; x < 2*PI ; x += (1/6) * PI ) {
    printf( "%lf %lf¥n" , x , sin( x ) ) ;
}

このプログラムは、1/6が整数型で行われるため(つまり0とPIを掛ける)、 xの値が変化しない。 これは、"x += (1.0/6.0) * PI" と書かなければならない。

2016年7月

          1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31            

アーカイブ

Google

このアーカイブについて

このページには、過去に書かれたブログ記事のうちプログラム応用カテゴリに属しているものが含まれています。

前のカテゴリはデータベース工学です。

次のカテゴリは創造工学演習です。

最近のコンテンツはインデックスページで見られます。過去に書かれたものはアーカイブのページで見られます。