C Programlama Dili'ne Giriş

  Dersler
* Önsöz

* Giriş
* Veri Tipleri, Değişkenler
* Operatörler
* Temel G/Ç Fonksiyonları
* Temel Kütüphane Fonksiyonları
* Karşılaştırma Deyimleri
* Döngüler
* Fonksiyonlar I
* Fonksiyonlar II
* Diziler
* Gösterici (Pointer) Kavramı
* Katarlar (Stringler)
* Dinamik Bellek Yönetimi
* Gösterici Uygulamaları
* Yapılar ve Birlikler
* Dosya Yönetimi
* Bit Düzeyinde Çalışmak
* Port Denetimi
* Grafik Kullanımı
* C Makroları

* Kısaca C++
* Derleme Seçenekleri
* Tarih-Saat Fonksiyonları
* Monte-Carlo Yöntemleri
* Fortran ve C

* Yararlanılan Kaynaklar

  C/C++ Derleyicileri
* Dev-C++
* Salford (silversoft FTN95)
* GCC
* Turbo C
* Eclipse IDE
* NetBeans IDE

  Dış Bağlantılar
* programlama.com
* C Programcıları Derneği

* C (wikipedia)
* C++ (wikipedia)
* cplusplus.com
* koders.com
* Hot scripts

  

Ders 23: Tarih ve Saat Fonksiyonları

###################- (%95)

En son güncelleme: Wed, 30 Nov 2011 13:22:02 +0200
Giriş

Bazı uygulamalarda program içerisinde tarih ve saat bilgilerine ihtiyaç duyulabilir. C dilinde, tarih ve saat fonksiyonlarının bildirimleri, semblik sabitler ve standart yapılar <time.h> başlık dosyasında tanımlanmıştır. Bu fonksiyonlar üç temel işlevi yerine getirir:

  • Takvim (Tarih) bilgileri
  • Yerel Saat
  • Saat Dilimleri
Bu bölümde tarih ve saat fonksiyonları incelenmişitir.


23.1   time() Fonksiyonu

time() fonksiyonu 01/01/1970 tarihinden, programın çalıştığı tarihe ve saate kadar geçen sürenin saniye cinsinden değerini gönderir. Genel bildirimi: 

      time_t time(time_t *zaman);
şeklindedir. Burada:
  • time_t sayısal bir tip (genllikle long int) olup zaman bilgisini temsil eder.
  • zaman tarih bilgisini tutan gösterici tipinde bir değişkendir.

 NOT
Derleyici tarih bilgisi göstermezse time() fonksiyonu -1 değerini gönderir.

01/01/1970'den bu güne geçen süreyi iki yolla öğrenebiliriz:
  1. Geri dönüş değerini kullanarak 
    time_t t;
...
t = time(NULL);
printf("zaman: %ld\n",t);
  2. fonksiyon parametresinden 
    time_t t;
...
time(&t);
printf("zaman: %ld\n",t);
Şimdi örnek uygulamayı Program 23.1'de görelim:

Program 23.1: time() fonksiyonunun kullanımı 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 

/* 23prg01.c: time() fonksiyonun kullanımı */

#include <stdio.h>
#include <time.h>

int main ()
{
  time_t saniye;   /* long saniye; anlamında */

  saniye = time (NULL);

  puts("01/01/1970'den bu gune kadar gecen sure,");

  printf ("Saniye olarak  %ld\n", saniye);

  /* 1 saat = 60*60 = 3600 sn. */
  printf ("Saat olarak    %ld\n", saniye/3600);

  /* 1 gün = 24 saat = 24*60*60 = 86400 sn. */
  printf ("Gun olarak     %ld\n", saniye/86400);

 return 0;
}

ÇIKTI 

01/01/1970'den bu gune kadar gecen sure,
Saniye olarak  1227606397
Saat olarak    341001
Gun olarak     14208


23.2   ANSI C Tarih-Saat Fonksiyonları, Sabitleri ve Yapıları

Tablo 23.1'de ANSI C'de <time.h> başlık dosyasında bildirilen tarih-saat fonksiyonları listelenmiştir.

Tablo 18.1: time.h'te tanımlı tarih-saat fonksiyonları
Fonksiyon Bildirimi Açıklama
char *asctime(const struct tm *zmn_g); zmn_g göstericinin işaret ettiği veriyi, daha anlaşılabilir bir formatla katar bilgisine çevirir. zmn_g göstericisi, gmtime() ve localtime() fonksiyonlarının döndürdüğü, tm yapısını gösterir. Geri döndürelen katarın genel formatı:
Www Mmm dd hh:mm:ss yyyy
şeklindedir. Burada Www haftanın günü, Mmm ay bilgisi, dd ayın günü hh:mm:ss saat bilgisini ve yyyy yıl bilgisidir.
clock_t clock(void); Zaman tik-tak bilgisini döndürür.
char *ctime(const time_t *zaman); Geriye anlaşılır formatta yerel zamanı tutan bir katar döndürür. zaman, time_t tipinde bir uzun tamsayıdır. Katarın formatı: Www Mmm dd hh:mm:ss yyyy şeklindedir.
double difftime(time_t zaman1, time_t zaman2); zaman2 - zaman1 farkını saniye cinsinden hesaplar.
struct tm *gmtime(const time_t *zaman); zaman'ı tm yapısına (İngiltere'deki Greenwitch'göre GMT cinsinden) çevirir. zaman genellikle time fonksiyonu ile döndürülür.
struct tm *localtime(const time_t *zaman); zaman'ı tm yapısına (yerel saat cinsinden) çevirir. zaman genellikle time fonksiyonu ile döndürülür.
time_t mktime(struct tm *zaman); tm tipinde, zaman göstericisine ait tarih-saat bilgisini gösterir.
time_t time(time_t *zaman); 1 Ocak 1970'den bu ana kadar geçen sürenin zaman saniye cinsinden hesaplar.
   
CLK_TCK (clock ticks per second) makro sabit. Zaman tik-takları ve zamanın saniye cinsinden karşılığı arasında ilişkiyi tanımlar. Bu sabit Turbo C'de
  #define CLK_TCK 18.2
şeklinde tanımlanmıştır.
clock_t ve time_t clock() ve time() fonksiyonlarının kullandığı veri tipleri. Bunlar genellikle genllikle long int tipleridir ve <time.h> başlık dosyasında şöyle tanımlıdır.
  typedef long clock_t
  typedef long time_t

asctime(), gmtime(), localtime() ve mktime() fonksiyonlarının kullandığı tm yapısı söyledir: 

struct	tm {
	int	tm_sec;    /* saniye,    (0 - 59) */
	int	tm_min;    /* dakika,    (0 - 59) */
	int	tm_hour;   /* saat,      (0 - 23) */
	int	tm_mday;   /* ayın günü, (1 - 31) */
	int	tm_mon;    /* ay,        (0 - 11), 0 = Ocak */
	int	tm_year;   /* yıl - 1900 */
	int	tm_wday;   /* haftanın günü, (0 - 6), 0 = Pazar */
	int	tm_yday;   /* yılın günü,(0 - 365) */
	int	tm_isdst;  /* gündüz  (-1/0/1)     */
};

Program 23.2: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 

/* 23prg02.c: asctime() ve localtime() fonksiyonlarının kullanımı */

#include <stdio.h>
#include <time.h>

int main()
{
  time_t t;
  struct tm *zaman_bilgisi;

  time (&t);
  zaman_bilgisi = localtime (&t);

  printf("Su anki tarih ve saat: %s",asctime(zaman_bilgisi));

 return 0;
}

ÇIKTI 

Su anki tarih ve saat: Tue Nov 25 15:19:20 2008

Program 23.3: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 

/* 23prg03.c: ctime() fonksiyonunun kullanımı */

#include <stdio.h>
#include <time.h>

main()
{
  time_t t;

  time(&t);
  printf("Su anki tarih ve saat: %s",ctime(&t));

 return 0;
}

ÇIKTI 

Su anki tarih ve saat: Tue Nov 25 17:08:02 2008

Program 23.4: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 

/* 23prg04.c: clock() fonksiyonunun kullanımı */

#include <stdio.h>
#include <time.h>

void bekle(int zaman)
{
  clock_t son;

  son =  clock() + zaman * CLK_TCK;

  while( clock() < son) {}
}


int main()
{
  int n;
  printf ("Geri sayim basladi...\n");

  for (n=10; n>0; n--)
  {
    printf ("%d\n",n);
    bekle(1000);
  }
  printf ("ATES!\n");

 return 0;
}

ÇIKTI 

Geri sayim basladi...
10
9
8
7
6
5
4
3
2
1
ATES!

Program 23.5: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 

/* 23prg03.c: difftime() fonksiyonunun kullanımı */

#include <stdio.h>
#include <time.h>

int main ()
{
  time_t basla, bit;
  char   ad[256];
  double fark;

  time (&basla);
  printf ("Lutfen adinizi girin: ");
  gets (ad);

  time (&bit);
  fark = difftime(bit, basla);

  printf("Merhaba %s.\n", ad);
  printf("Adini yazman %lf saniye surdu.\n",fark);

 return 0;
}

ÇIKTI 

Lutfen adinizi girin: Ahmet
Merhaba Ahmet.
Adini yazman 2.000000 saniye surdu.

Program 23.6: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 

/* 23prg06.c: mktime() fonksiyonunun kullanımı */
#include <stdio.h>
#include <time.h>

int main ()
{
  time_t t;
  struct tm *zaman;
  int yil, ay, gun;
  char *haftanin_gunu[] = { "Pazar", "Pazartesi",
                             "Sali",  "Carsamba",
                             "Persembe", "Cuma", "Cumartesi"};

  /* tarih bilgisini oku  */
  printf("Yılı girin: ");  scanf ("%d",&yil);
  printf("Ayı  girin: ");  scanf ("%d",&ay);
  printf("Gunu girin: ");  scanf ("%d",&gun);

  /* simdiki zaman bilgisini al */
  t = time(NULL);
  zaman = localtime(&t);

  zaman->tm_year = yil - 1900;
  zaman->tm_mon  = ay - 1;
  zaman->tm_mday = gun;

  /* mktime fonksiyonun cagir */
  mktime(zaman);

  printf("Girilen tarihteki gun  %s.\n", haftanin_gunu[zaman->tm_wday]);

  return 0;
}

ÇIKTI 

Yılı girin: 2003
Ayı  girin: 8
Gunu girin: 1
Girilen tarihteki gun  Cuma.

Program 23.7: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 

/* 23prg07.c: gmtime() fonksiyonunun kullanımı */

#include <stdio.h>
#include <time.h>

#define TUR  (2)
#define ALM  (1)
#define ABD (-8)

int main()
{
  time_t t;
  struct tm *ptm;

  time (&t);

  ptm = gmtime(&t);

  printf("Su anki yerel saatler\n");
  printf("Istanbul   : %02d:%02d\n", ptm->tm_hour + TUR, ptm->tm_min);
  printf("Berlin     : %02d:%02d\n", ptm->tm_hour + ALM, ptm->tm_min);
  printf("Los Angeles: %02d:%02d\n", ptm->tm_hour + ABD, ptm->tm_min);

 return 0;
}

ÇIKTI 

Su anki yerel saatler
Istanbul   : 18:34
Berlin     : 17:34
Los Angeles: 08:34

Program 23.8: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 

/* 23prg08.c: gerçek zamanı gösterimi */

#include <stdio.h>
#include <time.h>

int main()
{
  time_t t;
  struct tm *zmn;

   puts("Cikis icin: CTRL+C");

   /* Sonsuz döngü */
   while(1)
   {
     time(&t);
     zmn = localtime(&t);

     printf("%02d:%02d:%02d\r",
            zmn->tm_hour, zmn->tm_min, zmn->tm_sec);
   }

 return 0;
}

ÇIKTI 

Cikis icin: CTRL+C
17:08:43


23.3   Mili Saniye ve Mikro Saniye Düzeyinde Çalışmak

Bazı uygulamalarda saniyenin (s) alt birimleri, salise (sl), mili saniye (ms) ve mikro saniye (μs), düzeyinde çalışmak gerekebilir. Birçok derleyici, saniyenin belli kesirlerine kadar erişime izin veren fonksiyonları bünyesinde barındırır. Ancak, bu fonksiyonlar satandart C'de mevcut değildir.

 NOT
1 sl = (1/100) s = 0,01 s
1 ms = (1/1000) s = 0,001 s
1 μs = (1/1000000) s = 0,000001 s

gcc derleyicisinde <sys/time.h> başlık dosyası içinde tanımlı, gettimeofday() fonksiyonu ile mikro-saniye düzeyine erişim mümkündür.

Program 23.9: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 

/* 23prg09.c: saniyenin alt birimleri 
   Derleyici gcc 4.1.2                  */

#include <stdio.h>
#include <time.h>
#include <sys/time.h>

int main()
{
  struct timeval tv;
  struct timezone tz;
  struct tm *tm;
  long int sa, dk, sn, us;
  double   sl, ms;

  gettimeofday(&tv,&tz);
  tm = localtime(&tv.tv_sec);

  sa = tm->tm_hour;        /* saat         */
  dk = tm->tm_min;         /* dakika       */
  sn = tm->tm_sec;         /* saniye       */
  sl = tv.tv_usec/1.0e4;   /* salise       */
  ms = tv.tv_usec/1.0e3;   /* mili-saniye  */
  us = tv.tv_usec;         /* mikro-saniye */


  printf("%02ld:%02ld:%02ld ; %lf  %lf  %ld\n",
           sa, dk, sn,  sl, ms, us);

 return 0;
}

ÇIKTI 

13:53:38 ;  65.247900  652.479000  652479

Program çalıştırıldığı andaki saniye 38 değerini göstermektedir. Daha doğrusu, program çalıştığı anda sistem saatinin saniye göstergesi 38. saniyeden 39. saniyeye geçmektedir. Çıktıdaki 652479 rakamı, 38. ve 39. saniyeler arası geçen zamanın μs cinsinden değeridir. Yani, saniyenin alt birimi 38 s + 652479 μs = 38.652479 s. demektir.


Turbo C deleyicisinde, mili-saniye düzeyinde kadar erişim izni vardır. Bunun için, program içerisinde <sys/timeb.h> başlık dosyasında tanımlı ftime() fonksiyonu kullanılabilir.

Program 23.9b: 
01: 
02: 
03: 
04: 
05: 
06: 
07: 
08: 
09: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 

/* 23prg09b.c: saniyenin alt birimleri
   Derleyici Turbo C 2.0              */

#include <stdio.h>
#include <time.h>
#include <sys/timeb.h>

int main()
{
  struct   tm    *zmn;
  struct   timeb *tb;  
  int      sa, dk, sn;
  double   sl, ms;
  
  sa = zmn->tm_hour;     /* saat   */
  dk = zmn->tm_min;      /* dakika */
  sn = zmn->tm_sec;      /* saniye */
  sl = tb->millitm/10.0; /* salise */
  ms = tb->millitm;      /* mili-saniye */

  ftime(tb);

  printf("%02d:%02d:%02d | %lf %lf\n", sa, dk, sn,  sl, ms);

 return 0;
}

ÇIKTI 

13:56:16 ;  35.600000  356.000000


Powered by PHP