bu makalemi İstanbul yolunda yazıyorum o yüzden fazla açıklama şu an eklemiyeceğim daha sonra makaleye ek yaparım

Öncelikle basit örneklerden başlayacağım;

basit bir class kullanarak çevre bulalım;

#include<iostream>

#include<conio.h>
using namespace std;
class cevre
{
      int x,y;
      public:
             void degerler(int,int);
             int alan()
             {
                 return x*y;                
                 }
                 };
     void cevre::degerler(int a,int b)
     {
          x=a;
          y=b;
          } 
          main()
          {
                cevre yeni;
                yeni.degerler(12,12);
                cout<<yeni.alan();
                getch();
                }

Uygulamada classımız ve fonksiyomuz ayrı dosyalarda main.cpp de fonksiyon ve kesir dosyalarını include ediyoruz fakat fonksiyon dosyası içerisinde kesir dosyasını kullandığımız için main de derlerken recompile hatası verecektir bunun önüne geçmek için classımızın başına;

#ifndef KESIR
#define KESIR
.
.//class tanım blogu
.
.
#endif

Koyuyoruz eğer bu dosya önceden derlenmişse derleme derlenmemişse derle demek;
Böylecİfndef ile classımız önceden derlenmiş mi diye kontrol ediyoruz derlenmemişse derleyecek;
Fonksiyonlarımızın prototiplerini oluşturduk;
Toplam operatörü tanımlıyoruz
Sinif operator +(sinif a,sinif b) bu tanımın başına friend koyduk çünkü parametre olarak iki sinif nesnesi gönderdik ve bu sınıfların private alanlarına ulaşmamız gerektiği için;

friend kesir operator-(kesir k1,kesir k2)
      {
      return kesir(k1.pay-k2.pay,k1.payda-k2.payda);
      }

Geri dönüş değerimiz bir kesir nesnesi bu aslında kurucu fonksiyon diyebiliriz aldığı parametlerle pay ve paydaya bu işlemden çıkan sonuclar atanıyor.
Yazdırma fonksiyonu ile diyerek degeri yazdırıyoruz;
cout< Şimdi bir yazdırma operatörü tanımlayalım ve işlerimiz daha kolaylaşsın

friend ostream& operator<<(ostream& os,kesir k)
      {
      os<<"["<
Bu işlem ile << operatörü gördüğü yerde 3/5 olan sonucu [3/5]  şeklinde yazacaktır.

Ostream de bir nesnedir.

Diger fonksiyonlarda cout kullandık köşeli parantez içerisine yazmadı çünkü o fonksiyon altından gelen parametreler bizim operatöre uygun değil
sadelestir(c);
cout<<"sadelestir c="<
Bu iki fonksiyonun birbirinden farklarını göstermek için yazdık bunların ikiside sadeleştirme yapıyor fakat fonksiyonların işi bittikten sonra çalıştırdığımızda ise birinci fonksiyonun asıl nesneyi değiştirmediği anlaşılıyor.

Çünkü argümanı kopyalayıp alıyor, ikinci fonksiyon ise asıl nesnenin referansını adreseni aldığı için direk sadeleştirmeyi yapıyor;

Referans olan değişkenlerde const ifadesini kullanın çünkü direk adrese müdahele edilebilidği için fonksiyon içeriği de değiştirileblir bunu önlemek için arguman tanımına const koymak gerekir.

Örnek verecek olursak;
Friend zaman operator *(const zaman& z1,int n)
{
Zaman z3;
Z1.saniye*=n;
Return z3;
}
burada

Zaman operatörü

Main den bir kurucu fonksiyon çagırıyoruz 3 parametreli bu parqametreler zamanın saniyesi dakikası ve saat değişkenleri;

İlk degerleri veriliyor zaman(int sa,int dk,int sn) kurucu fonksiyonunda

Kopyalayıcı kurucu fonksiyon;

Argüman olarak kurucu olduğu sınıf türünden bir referans alır.

zaman(const zaman& z)

{

}
sınıflar ve işaretçiler;
int *p;
int i=6;
p=&i;
*p=12;
cout<

bu şekildeki bir tanım da

bir değişkenin adresini yazdırmak için & operatörü adresteki değeri yazdırmak için * operatörü kullanılır.

eleman a,b,c;

eleman *p;

p=&a;

*p.Adi()="serdar";

*p.odeme(200);

Elaman sınıfımız var ve eleman türünden bir işaretçi tanımlamak için  eleman *p; yazdık .

P=&a; dememizdeki amaç a da bir sınıf olduğu için tek bir değer içermez dolayısıyla * işretçisinin yaptıgı gibi o adresteki değeri değil o adresteki nesneye erişir. Bu örnek te sinifin fonksiyonlarına erişmek için & ve * operatörlerini birlikte kullandığımız için öncelik sırasında bir sorun yaşayabiliriz.

Bu sorunu çözebilmek için -> üye işlemcisi kullanılabilir. Yani şu şekilde yazabiliriz kodu:
p->Adi()=”serdar”;
p->Odeme(200);
işaretçilerin kullanımı dizilerde işe yarar.
Eleman personel[10];
Eleman *p;
For(p=personel;p->personel<10;p++)
{
p->Odeme(200);
}
Bu kodda p işaretçisiyle dizinin başlangıç adresini p ye atıyoruz. Ve adresi arttırarak diger elemanlara erişmiş oluyoruz.

Bunu klasik yöntem le yapalım;
İnt i;
Eleman dizi[10];
For(i=0;i<10;i++)
{
personel[i].odeme(100);
}
Şekilnde de tanımlayabilirdik.
New komutu;
İnt *pi;kesir *pk; zaman *pz,*pzc;
Pi=new  int ;
Pk=new kesir(2,4); //başlangıç degerleri atanmış kurucu fonksiyon oluşturdu.
Pz=new zaman[50];//zaman türünden 50 nesne içeren bir dizi oluşturdu.
Şimdi bu işlemleri yapıp yapmadığını kontrol edelim;
İf(pz!=NULL)
{
for(pzc=pz;pzc-pz<50;pzc++)
{
pzc->saat=1;
Pzc->dakika=0;
Pzc->saniye=0;
}
}
Burada ise 50 elemanlı nesneyi oluşturmadı ise dizinin başlangıç adresini bir değişkende(pz de) tutuluyor pzc değişkenine adres atanıp adres arttırılıyor pz de dizimizin adresini saklıyoruz unutmamak için.

New ile işaretçi kullanarak  tanımladığımız dizide ise adresin değişmemesi için adresi sabitlemek doğru bir seçim olur.

Const zaman *pz=new zaman[50];

Delete işlemi

Kesir *pk=new kesir(2,5);

..

.
.

Delete pk;

Zaman *pz=new zaman[50];

.

.

.

.delete pz;

Dediğimizde ilk elemanı siler diğer dizi elemanlarını görmezden gelir.

Bunun için şu şekilde yazmalıyız

Delete []pz;