Milenyum’un İnsan Tipleri

Human Types of Millennium

Mehmet Keçeci

2000/Yalova

 Milenyum

 

Her şey baş döndürücü bir hızla ilerlerken insanlarda bu kervanın bir yerlerinde kendi dünyasında yavaş veya hızlı bir şekilde ilerlemektedir.

Binlerce çalışma alanı, binlerce bilim dalı, binlerce hayat tarzı ve bunların arasında bunların ortak özelliklerini yakalayıp olması gereken yâda olmaması gereken insan denen psiko-sosyal bir canlının diğer farklı bir psiko-sosyal canlı ile içtimai (sosyal) ilişkilerinin aynı düzeyde olması elbette beklenemez.

Hayat tarzını (life-sytle, modus vivendi) kendi idealleri doğrultusunda şekillendiren bir insan zaman içinde yavaş yavaş sanal dünyası gerçek dünyasına baskın gelecek ve toplumdan soyutlanmaya başlayacaktır. Bu durumu kendisi için çok doğal kabul ederken kendilerini doğal dünyada addedip ideallerden uzak olan bir insan ile böyle bir kişiliğin sosyal ilişkileri oldukça kısıtlı olmakta ve bunlara benzer psiko-sosyal tipler kendilerine uygun zemin oluşturabilmektedirler.

Bu bilim ve teknolojinin bir sonucu mudur? Yoksa hayat pahasına da olsa bir şuursuz rekabetin, Makyavel’in “Hedefe ulaşmada her şey caizdir” hayat felsefesinin bir ürünü yada bilimden yoksun teknolojiye hakim olma rekabetinin “iyi bir eğitim + iyi bir iş + iyi bir eş’e” sahip olma idealine “son model teknolojik marka” eklenti psikoloji şartlanmaları bireylerin ve toplumların yapılanmaları yerine dış görüntülere önem vermeleri, her başarısızlık ve kayıpta stres ve depresyon geçirmeleri normal görünümlü anormal insan ve toplum yapısı oluşturmuş, sosyal piramit yapısından asosyal yıldız yapısına geçilmiştir. Suç ne Milenyum da ne de Bilim ve Teknolojide, suç insanların hayata bakış açılarının evrensel boyutlardan bireysel fasit dairevi bakış açılarına indirgenmesidir.

Sonuç olarak teknolojiyi bir morfin ve uyuşturucu gibi kullanan materyalist organizasyonların sosyal-kaos’a katkılarını da unutmamak gerekir.

Yayın Tarihi/Yer: 2000-Yalova

Yazar: Mehmet Keçeci

Ders 7: C++’da Yorumlar

Lesson 7: Comments with C++

Mehmet Keçeci

04.04.2000

 

Yorumlar programcı tarafından yapılan açıklamalardır ve bunlar derleyici tarafından işlenmezler.

C++ 2 türlü yorumlayıcısı vardır

 

  1.  <span class=“comm”>// tek satır yorumlayıcı-</span>line comment 
  2. <span class="comm">/* blok (çok satır) yorumlayıcı- block comment */</span>

  

<span class="comm">/* yorumlayıcı ile </span> 
<span class="comm">gösterilen örnek */</span>
<span class="prep">#include <iostream></span>
<span class="kw">using</span> <span class="kw">namespace</span>
std; 
<span class="kw">int</span> 
main () 
{ cout << <span class="str">"Merhaba Dünya! "</span>; 
<span class="comm">// Merhaba Dünya! yazar</span> 
cout << <span class="str">"Ben bir C++ programcısıyım."</span>; 
<span class="comm">// </span><span class="str">Ben bir C++ programcısıyım. yazar</span> 
<span class="kw">return</span> 0; }
<span class="comm">Merhaba Dünya!</span>
<span class="str">Ben bir C++ programcısıyım.</span>
<span class="comm"></span> 

 

Eğer bu ifadeleri //, /* or */ kullanmadan yorum yazarsak derleyici bize hata kodları verir.

Ders 6: Operatörler ve C++’da Genel Konu ve Terimler

Lesson 6: Operators and C++‘s General Topics and Terms

Mehmet Keçeci

04.04.2000

Operator (İşleç): Bir işlemi gösteren semboldür ve kendisi işlemin nesnesidir, yapılan işlemi gösterir.

(*: çarpma işleci, +: toplama işleci gibi yapılan işlemi bize verirler)

*: Çarpma

/: bölme

+: toplama

-: çıkarma

!: Mantıksal değildir

&&: Mantıksal ve

||:  Mantıksal veya

C++ da Genel Konu ve Terimler

C + + ‘s General Topics and Terms

  1. Programlama Kavramı ve Programlamanın temelleri
  2. C++”ın programlamadaki yeri ve uygulamaları
  3. C++ Dilinin temel elamanları
  4. Temel veri tipleri ve işlemler
  5. Fonsiyonlar, fonksiyon yükleme
  6. İşaretçiler ve dinamik bellek yönetimi
  7. Diziler
  8. Nesne tabanlı programlamanın temelleri
  9. Sınıf, Şablon sınıfları
  10. Nesneler
  11. İşleç (0perator) yükleme
  12. – Ekrandan okuma ve ekrana yazdırma
  13. İsim uzayları
  14. Miras alma ve çok biçimlilik
  15. Yapıcılar ve yıkıcılar
  16. Nesnelere giriş ve “nesne tabanlı merhaba”
  17. Yapıcılar ve atama işleci
    > – Temel akış denetimi
    > – Yöntemler ve yöntem yükleme
    > – Birden fazla dosya kullanmak ve isim uzayları
    > – Proje organizasyonu ve GNU make
    > – KDevelop
    > – Genellenmiş teknikler ve şablon yazmak
    > – STL”deki temel veri yapıları ve adımlayıcılar
    > – Yüksek seviye algoritmalar ve algoritma nesneleri
    > – Çeşitli tasarım biçimlerinin C++”da uygulanması
    > – Düşük seviye algoritmalar kurmak ve kapsam kuralları
    > – Bellek modelleri, durağan değişkenler, işaretçiler ve diziler
    > – Dizi algoritmaları
    > – Dinamik bellek yerleşimi ve yıkıcılar
    > – İşleç yükleme
    > – Dosyalarla çalışma
    > – Miras alma teknikleri ve çok biçimliliğe giriş
  18. Data Types, Storage Classes, & Scope
    Pointers, Arrays, and Dynamic Allocation
    Compiler Directives, Preprocessor, and Macros
    Operators and Expressions
    Functions and C Runtime Library
    Structures and Unions
  19. ANSI C Programming Course Overview:
    Overview of C
    Operating System Independence
    Design Goals and Capabilities
    Flavors of C
    Compiler Directives and the C Preprocessor
    Compile-Time Directives
    Use of typedef
    C Preprocessor Syntax
    Fundamental Data Types, Storage Classes, and Scope
    Fundamental Data Types and Qualifiers
    Constants and Strings
    Storage Classes
    Scope and Block Structure
    Scope and Data Hiding
    Data Initialization
    Pointers and Dynamic Allocation
    Advantages of Pointers
    User of Pointers
    Pointer and Address Arithmetic
    Dynamic Storage Allocation
    sizeof
    Double Indirection
    Macros
    Functions versus Inlining
    Purpose of Macros
    Use of Macros
    Making Code More Readable
    Auto Adjustment of Compile Time Values
    Conditional Compilation
    Making Code Portable
    Simplifying Complex Access Calculations
    Advanced Micro Design Tips
    Using Macros to Help Write Portable Programs
    When to Use a Macro instead of a Function
    Using Macros for Debugging
    Arrays
    Purpose of Arrays
    Declaring an Array
    Initializing an Array
    Addressing Elements
    Stepping Through an Array
    Variable Size Arrays
    Arrays of Pointers
    Arrays of Strings
    Passing an Array to a Function
    Dynamic Memory Allocation
    Multidimensional Arrays
    Basic Formatted I/O
    Standard I/O Library
    Character Set Encoding
    Standard Input and Output
    Character I/O Functions
    Formatted I/O Functions
    String Constants
    Program Debugging
    Problem Analysis
    Instrumenting with printif
    Instrumenting with ctrace
    The Purpose of Debuggers
    How Not to Use Debuggers
    Symbolic Debuggers
    Operators and Expressions
    Arithmetic, Logical, and Bit Operators
    Precedence and Associativity
    Assignment and Casting
    The Conditional Operator
    Flow Control Constructs
    Conditional Constructs: if, switch
    Looping Constructs: while, do, for
    Programming Style
    Functions (Subroutines)
    Purpose of Functions
    Functions versus Inlining
    Automatic Variables
    The Argument Stack
    Passing By Value
    Passing By Reference
    Declaring External Functions
    Function Prototyping
    ANSI Prototyping
    The _NO_PROTO Compiler Symbol
    Varargs Functions
    Passing a Function as an Argument
    Designing Functions for Reusability
    Calling a Function from Another Language
    Returning a Dynamically Allocated Value Using Double Indirection
    Casting the Return Value of a Function
    Recursion and Reentrancy
    Structures
    Purpose of Structures
    Defining and Declaring Structures
    Accessing Members
    Pointers to Structures
    Dynamic Memory Allocation
    Passing a Structure to a Function
    As a Pointer
    Passing the Actual Structure
    Advanced Structures and Unions
    Nested Structures
    Arrays of Structures
    Bit Fields
    Unions
    Linked Lists
    C Runtime Library Standard Functions
    Character I/O
    Unformatted File I/O
    Formatted File I/O
    Math Functions
    Miscellaneous Functions
    Strings and Character Manipulation
    Strings as Character Arrays
    String Library Functions
    Reading and Writing Strings
    Accessing Command Line Arguments and Environment Symbols
    argc and argv
    Parsing Command Line Options
    Accessing the Environment Array
    Structured Programming
    Structuring Code for Quality, Reliability, Maintainability
    Designing for Modularity and Reusability
    Advanced Programming Consideration
    Writing Portable Code
    Use of Macros
    ANSI C Limits
    Feature Test Macros
    Client/Server Design
    Performance Considerations

 Ders 5: C++ ile Tarih Belirleme

Lesson 5: Date Determination with C++

Mehmet Keçeci

04.04.2000

11. Örnek: Tarih Belirleme

#include <iostream>
#include <ctime>

using namespace std;

 

class Tarih {
int gun, ay, yil;
int toplamgun;
static bool is_valid(int, int, int);
static bool is_leap(int y) {
return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
}
static int gunler[][13];
static int yillar[2];
static const char *sgun[];
static const char *say[];
static const int yiltabani = 1700;
static const int faktor = 3;
void toplamgunler();
void revTarih(int toplamgunler1);
public:
Tarih(int, int, int);
Tarih();
int get_yil_gun()const;
int get_hafta_gun()const;
int get_gun()const {return gun;}
int get_ay()const {return ay;}
int get_yil()const {return yil;}
Tarih &operator+=(int n);
Tarih &operator-=(int n);
Tarih &operator++();
Tarih operator++(int);
Tarih &operator–();
Tarih operator–(int);

 

friend std::ostream &operator<<(std::ostream &, const Tarih &);
friend std::istream &operator<<(std::istream &, Tarih &);
friend bool operator<(const Tarih &, const Tarih &);
friend int operator-(const Tarih &, const Tarih &);
};

 

class KotuTarih{};

 

//GLOBAL fonksiyon dekrerasyonu
bool operator>(const Tarih &, const Tarih &);
bool operator>=(const Tarih &, const Tarih &);
bool operator<=(const Tarih &, const Tarih &);
bool operator==(const Tarih &, const Tarih &);
bool operator!=(const Tarih &, const Tarih &);
Tarih operator+(const Tarih &, int);
Tarih operator+(int, const Tarih &);
Tarih operator-(const Tarih &, int);

 

int Tarih::gunler[2][13] = {
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};

 

int Tarih::yillar[] = {365, 366};

 

const char *Tarih::say[] = {“”, “Ocak”, “Subat”, “Mart”, “Nisan”, “Mayis”,
“Haziran”, “Temmuz”, “Agustos”, “Eylul”,”Ekim”, “Kasim”, “Aralik”};

 

const char *Tarih::sgun[] = {“Pazartesi”, “Sali”, “Carsamba”, “Persembe”,
“Cuma”, “Cumartesi”, “Pazar”};

 

Tarih::Tarih(int g, int a, int y)
{
if (!is_valid(g, a, y))
throw KotuTarih();

gun = g;
ay = a;
yil = y;
toplamgunler();
}

 

Tarih::Tarih()
{
time_t timer = time(0);
tm *tp = localtime(&timer);
gun = tp->tm_mday;
ay = tp->tm_mon + 1;
yil = tp->tm_year + 1900;
toplamgunler();
}

 

int Tarih::get_yil_gun()const
{
int yilgun = gun;

for (int k = 1; k < ay; ++k)
yilgun += gunler[is_leap(yil)][k];

return yilgun;
}

 

int Tarih::get_hafta_gun()const
{
return (toplamgun + faktor) % 7;
}

 

Tarih &Tarih::operator+=(int n)
{
revTarih(toplamgun + n);
return *this;
}

 

Tarih &Tarih::operator-=(int n)
{
revTarih(toplamgun – n);
return *this;
}

 

Tarih &Tarih::operator++()
{
return *this += 1;
}

 

Tarih Tarih::operator++(int)
{
Tarih retval(*this);
++*this;

return retval;
}

 

Tarih &Tarih::operator–()
{
return *this -= 1;
}

 

Tarih Tarih::operator–(int)
{
Tarih retval(*this);
–*this;

return retval;
}

 

void Tarih::toplamgunler()
{
toplamgun = 0;

for (int k = yiltabani; k < yil; ++k)
toplamgun += yillar[is_leap(k)];

toplamgun += get_yil_gun();
}

 

void Tarih::revTarih(int toplamgunler1)
{
toplamgun = toplamgunler1;
yil = yiltabani;

while (toplamgunler1 > yillar[is_leap(yil)])
toplamgunler1 -= yillar[is_leap(yil++)];
ay = 1;

 

while (toplamgunler1 > gunler[is_leap(yil)][ay])
toplamgunler1 -= gunler[is_leap(yil)][ay++];

gun = toplamgunler1;
}

 

bool Tarih::is_valid(int d, int m, int y)
{
if (y < yiltabani)
return false;

if (m < 1 || m > 12)
return false;

 

return m > 0 && m <= gunler[is_leap(y)][m];
}

 

ostream &operator<<(ostream &os, const Tarih &r)
{
return os << r.gun << ” ” << Tarih::say[r.ay] << ” ” << r.yil
<< ” ” << Tarih::sgun[r.get_hafta_gun()];
}

 

istream &operator<<(istream &is, Tarih &r)
{
int g, a, y;
is >> g >> a >> y;

 

if (!Tarih::is_valid(g, a, y))
throw KotuTarih();

r.gun = g;
r.ay = a;
r.yil = y;

 

r.toplamgunler();
return is;
}

 

bool operator<(const Tarih &d1, const Tarih &d2)
{
return d1.toplamgun < d2.toplamgun;
}

 

bool operator>(const Tarih &d1, const Tarih &d2)
{
return d2 < d1;
}

 

bool operator>=(const Tarih &d1, const Tarih &d2)
{
return !(d1 < d2);
}

 

bool operator<=(const Tarih &d1, const Tarih &d2)
{
return !(d2 > d1);
}

 

int operator-(const Tarih &d1, const Tarih &d2)
{
return d1.toplamgun – d2.toplamgun;
}

 

Tarih operator+(const Tarih &d, int n)
{
return Tarih(d) += n;
}

 

Tarih operator+(int n, const Tarih &d)
{
return d + n;
}

 

Tarih operator-(const Tarih &d, int n)
{
return Tarih(d) -= n;
}

 

int main()
{
Tarih d1(27, 2, 2005);
Tarih d2(d1 + 25);

while (d1 < d2)
cout << d1++ << endl;

return 0;
}

 Ders 4: C++ Örnekleri

Lesson 4:Examlpes with C++

Mehmet Keçeci

04.04.2000

10. Örnek

#include<iostream>
#include<conio.h> //getch(); için
using namespace std;

main()
{

cout<<“Merhaba dunya\\n” ;

getch(); //Ekranın hemen kapanmamasını sağlar

}

11. Örnek: Sayı Bulmaca

#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;

 

void Start ();
void GetResults ();

 

int i, j, hayat, maksimum; //int tamsayı tanımlar
char c; //char karakter tanımlar

 

void
Start ()
{
i = 0;
j = 0;
hayat = 0;
maksimum = 6;

 

cout << “Zor modu sec:\\n”;
cout << “1 : Kolay (0-20)\\n”;
cout << “2 : Orta (0-40)\\n”;
cout << “3 : Zor (0-60)\\n”;
cout << “veya cikmak için farkli bir sey secin\\n”;
c = 30;

 

cin >> c; // kullanıcının seçimmini okur
cout << “\\n”;

 

switch (c) //Seçimime göre aşagıdaki şıkları işletir
{
case ”1” : maksimum = 20; // Rastgele sayı 0 ile maksimum arasında olacaktır
break;
case ”2” : maksimum = 40;
break;
case ”3” : maksimum = 60;
break;
default : exit(0); //hiç biri değilse ekranı kapatır
break;
}

 

hayat = 6; // oyuncunun kaç seçim yapacağını belirler
srand( (unsigned)time( NULL ) ); // tamsayı rastgele sayı üreten fonksiyon
j = rand() % maksimum; // j 0 ile maximum sayı arasında bir sayıyı tutar

 

GetResults();

 

}

 

void
GetResults ()
{
if (hayat <= 0)
// şayet 6 seçim sonundada bilemezsiseniz
{
cout << “Kaybettiniz !\\n\\n”;
Start();
}

 

cout << “Bir sayi: \\n”;
cin >> i; // oyuncunun sayısını okur

 

if ((i>maksimum) || (i<0)) // şayet oyuncunun sayısı doğru değilse tekrar başlatır.
{
cout << “Hata : Sayi 0 ile ” << maksimum << ” arasinda degil\\n”;
GetResults();
}

 

if (i == j)
{
cout << “Kazandiniz !\\n\\n”; // Oyuncu doğru sayıyı bulursa
Start();
}

 

else if (i>j)
{
cout << “Cok buyuk\\n”;
hayat = hayat – 1; // secenek sayınızı bir azaltır
cout << “Kalan sayi hayat: ” << hayat << “\\n\\n”;
GetResults();
}

 

else if (i<j)
{
cout << “Cok kucuk\\n”;
hayat = hayat – 1;
cout << “Kalan sayi hayat:\\n” << hayat << “\\n\\n”;
GetResults();
}
}

 

int
main ()
{
cout << “** Sayi bulmaca **\\n”;
cout << “Secilen bir sayiyi bulacaksiniz. \\n”;
cout << “5 tahmin hakkiniz var\\n”;
cout << “Sayi bulmaca size çok buyuk veya cok kucuk olarak bildirecek ve sizde tahmin edeceksiniz\\n\\n”;
Start();
return 0;
}