类/对象/构造函数/析构函数

最近找工做，发现不少都是要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的规则读就能够了

}