类和对象

类和对象

类

def：类是具有相似的内部状态的和行为的集合；（类是面向对象的基础）

类的定义

class <ClassName>
{
private:
public:
}

class:类说明的关键字：
：类名；

类的访问控制

共有成员：public：在程序的任何位置都可以正确的引用；
私有成员：private：只能被自身的成员引用；
保护成员：protect：只能在派生类的类体中引用；
友 元：friend

构造函数

构造函数的概念

C++不允许在类的成员定义的时候为他们初始化，但是在定义之后一一初始化显的很繁琐，因此构造函数用来解决类的初始化的问题。
构造函数的名称与类的名称一样，主要的功能是为对象分配空间以及完成对象的初始化。构造函数不能有返回值，不能有return语句。

构造函数的声明和定义

class complex
{
    private:double real, imag;    //私有成员
    public:                      //公有成员
    complex(double real=0.0,double imag=0.0); //构造函数申明
    ~complex();//析构函数
    double c();//成员函数
    void  friend disp(complex *p);//友元函数
};

构造函数定义

complex::complex(double r,double i)
{
    real = r;
    imag = i;
}

构造函数的调用

一般在定义对象的时候调用构造函数完成独享的初始化。

complex ss(3, 4);

构造函数的的参数

构造函数可以不带参数；
也可以带默认参数；

拷贝构造函数

析构函数

析构函数是一种特殊的成员函数，被申明为公有的成员函数。不同的是，析构函数的作用是释放分配给对象的内存空间。
注意点：
1>析构函数的名字与类相同，在前面加“~”：
2>析构函数不带参数；没有返回值；
3>撤销独对象时，系统自动调用析构函数

~complex();//析构函数申明
complex::~complex()//析构函数
{
    cout << "释放空间"<<endl;
}

友元

友元与普通的成员函数不同，他不是类肚饿成员函数；但是他可以引用类的成员；

友元函数

如果友元是一个函数，叫做友元函数；

友元类

如果是一个类，则叫做友元类；

友元成员

如果一个类的成员函数是一个类的有友元函数，则这个函数为友元成员

void  friend disp(complex *p);//友元函数申明
void disp(complex *p)        //友元函数定义
{
    cout << p->real << "+" << p->imag << "i";
}
disp(&ss);               //友元函数引用

代码

// 类和对象.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream> 
using namespace std;
class complex
{
    private:double real, imag;    //私有成员
    public:                      //公有成员
    complex(double real=0.0,double imag=0.0); //构造函数 
    ~complex();//析构函数
    double c();//成员函数
    void  friend disp(complex *p);//友元函数
};
complex::complex(double r,double i)//构造函数 
{
    real = r;
    imag = i;
}
complex::~complex()//析构函数
{
    cout << "释放空间"<<endl;
}
double complex::c()//成员函数
{
    double n= real*real + imag*imag;
    return n;

}
void disp(complex *p)//友元函数
{
    cout << p->real << "+" << p->imag << "i";
}

class A
{
private:

public:
    int t;
    void inits(int n)
    {
        t = n;
    }
};
class B :public A
{

private:

public:
    int s;
    void initt(int n)
    {
        s = n;
    }
};


int _tmain(int argc, _TCHAR* argv[])
{
    complex ss(3, 4);
    cout << endl;
    cout<<ss.c();
    cout << endl;
    disp(&ss);


    B ob;
    ob.inits(15);
    ob.initt(51);
    cout << ob.s << "  " << ob.t << endl;
    return 0;
}

对象

def：对于一个具体的类，它具有多个具体的个体，这就是对象；也就是说，类是对象的抽象，对象是类的具体化；