類/對象/構造函數/析構函數

最近找工做，發現不少都是要c++的，所以失去了不少機會。決定把c++看起來

發現類和對象的基本原理仍是不太難的，

c++結構體和類有什麼區別？（面試愛考）

我想c中的結構體和c++中的結構體可能由於編譯器的不一樣，而使結構的對齊方式不同，這樣就致使sizeof一個結構體可能返回不一樣的值

但是一樣是c++，結構體和類又有什麼區別呢？結構體默認是public，而類默認爲private，其它方面聽網上的仁兄說：沒有差異！

要學c++，我先把平臺移到我許久沒用的vc++ 6.0上來

#include "stdafx.h"
#include "iostream.h"

class circle
{
   private:
    int x,y,r,s;
   public:
    void print();
    void circle::addarea(circle p1,circle p2);
      void circle::display();
    circle();
    circle(int a,int b,int c);
    ~circle();
};

void circle::print()
{
    cout<< "圓心:"<< "("<<x<< ","<<y<< ")"<<endl;
    cout<< "半徑:"<<r<<endl;
}
void circle::addarea(circle p1,circle p2)//計算兩圓面積和
{
         s=3.14*(p1.r*p1.r)+3.14*(p2.r+p2.r);
}
void circle::display()
{
         cout<< "面積和爲："<<s<<endl;
}

//構造函數能夠重載，當本身有寫新的構造函數，系統原來默認的構造函數消失，若是還想要，則要本身去重載；只能系統調用，不能由程序調用
circle::circle()
{
}
circle::circle(int a,int b,int c)
{
         x=a;y=b;r=c;
}
//析構函數和構造函數同樣，一旦有寫新的析構函數，系統原來默認的析構函數消失，而且不能重載；能夠由系統自動調用，也能夠由程序調用
circle::~circle()
{
  cout<< "析構:"<<x<< ","<<y<< ","<<r<<endl;
}

int main(int argc, char* argv[])
{
  circle p1(0,0,6);
  p1.print();

  circle *p2= NULL;
  p2= new circle(0,0,7);
  p2->print();
        
  circle p3;//由於有重載構造函數的存在
  p3.addarea(p1,*p2);
  p3.display();

  delete p2;
  p2= NULL;

  return 0;
}

程序執行結果及分析：

圓心:(0,0)

半徑:6

//這是執行circle p1(0,0,6);p1.print();的結果

圓心:(0,0)

半徑:7

//這是執行circle *p2=NULL;p2=new circle(0,0,7);p2->print();的結果

析構:0,0,6

析構:0,0,7

//這是執行p3.addarea(p1,*p2);的結果

//首先這個函數的兩個形參利用重載構造函數中的一個來建立了實實在在的對象，而後由於調用的緣故，p1,p2做爲實參拷給了兩個形參，初始化的數據也給了形參，因而形參的數據成員就有了值。可是這兩個形參是棧變量，函數執行完畢以後要銷燬的，因此就執行到了析構函數那裏，就有了這個

面積和爲：157

//這是執行p3.display()的結果

析構:0,0,7

//這裏執行delete p2;p2=NULL;的結果，

析構:-858993460,-858993460,-858993460

//由於程序要接受了，這種對象都會自動銷燬的，因而銷燬到了p3這裏，但是p3的建立的時候，調用的構造函數但是沒有給數據成員複製的啊，因而，銷燬的時候也是一堆不肯定數據

析構:0,0,6

//最後銷燬p1

剛纔在程序中，也看到了，那個做爲參量的類的對象賦給另一個被建立的同類對象，能夠作對象的初始化之用

那它究竟是怎麼實現的，首先這個是系統自帶的，編譯系統會自動生成一個缺省的拷貝初始化構造函數，其實現的大體原理是引用，基本上以下代碼

#include "stdafx.h"
#include "iostream.h"

class circle
{
private:
  int x,y,r;
public:
  void print();
  circle(int a,int b,int c);
  circle(circle &p);
};

void circle::print()
{
  cout<< "圓心:("<<x<< ","<<y<< ")"<<endl;
  cout<< "半徑:"<<r<<endl;
}
circle::circle(int a,int b,int c)
{
  x=a;
  y=b;
  r=c;
}
circle::circle(circle &p)
{
  x=p.x;
  y=p.y;
  r=p.r;
}

int main(int argc, char* argv[])
{
  circle p1(0,0,1);
  circle p2(p1);
  p1.print();
  p2.print();

  return 0;
}

其結果以下：

圓心:(0,0)

半徑:1

圓心:(0,0)

半徑:1

可見，利用引用來實現拷貝初始化構造函數

鄙人私下裏認爲，把上述的程序好好看懂，類的基本概念也懂得差很少了

不過，鄙人再補充兩點：

1》類的數據成員不能在聲明時進行初始化，只能經過成員函數來實現

2》自身類的對象不能做爲本身的成員，但自身類的指針能夠做爲本身的成員

class A

{

   private:

      int x=0;//錯，不能再聲明時初始化，必須用成員函數來實現

      A a1;   //錯，自身類的對象不能做爲本身的成員，由於要分配內存，而類都沒定義徹底，固然是不容許這麼作的

      A *a2;  //只是一個指針而已，未來有了內存，再把那一片內存按circle的規則讀就能夠了

}