最近找工作,发现很多都是要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的规则读就可以了
}