类和对象的基本概念和用法

结构化（面向过程）程序设计的不足

面向对象程序设计（OOP）

类和对象

#include<bits/stdc++.h>
using namespace std;
class Rect{//class 类关键字 Rect 类名
    public:
        int w,h;//成员变量
        int Square(){return w*h;}//成员函数
        int Parameter(){return 2*(w+h);}
        void Init(int _w,int _h){
            w=_w;
            h=_h;
        }
};//分号不能少
int main(void)
{
    int w,h;
    cin>>w>>h;
    Rect r;//r是一个对象
    r.Init(w,h);//调用成员函数
    cout<<"The square of the rectangle is"<<ends<<r.Square()<<endl;
    cout<<"The parameter of the rectangle is"<<ends<<r.Parameter()<<endl;
}

内存分配

对象间的运算

类的成员变量和成员函数的用法

用法一：对象名.成员名

#include<bits/stdc++.h>
using namespace std;
class Rect{
    public:
        int w,h;
        int Square(){return w*h;}
        int Parameter(){return 2*(w+h);}
        void Init(int _w,int _h){
            w=_w;
            h=_h;
        }
};
int main(void)
{
    Rect r1,r2;
    r1.w=5;//对象r1中的成员变量w初始化为5
    r2.Init(5,4);//对象r2中的成员变量w和h分别初始化为5和4
    return 0;
}

用法二：指针->成员名

#include<bits/stdc++.h>
using namespace std;
class Rect{
    public:
        int w,h;
        int Square(){return w*h;}
        int Parameter(){return 2*(w+h);}
        void Init(int _w,int _h){
            w=_w;
            h=_h;
        }
};
int main(void)
{
    Rect r1,r2;
    Rect *p1=&r1，*p2=&r2;
    p1->w=5;//作用在对象r1上
    p2->Init(5,4);//作用在对象r2上
    return 0;
}

用法三：引用名.成员名

#include<bits/stdc++.h>
using namespace std;
class Rect{
    public:
        int w,h;
        int Square(){return w*h;}
        int Parameter(){return 2*(w+h);}
        void Init(int _w,int _h){
            w=_w;
            h=_h;
        }
};
void fixRect(class Rect rr){//参数是类本身
        rr.h=7;
        rr.w=8;
        return;
}
void FixRect(class Rect &rr){//参数是类的引用
        rr.h=7;
        rr.w=8;
        return;
}
int main(void)
{
    Rect r;
    r.h=5,r.w=6;
    cout<<r.Square()<<ends<<r.Parameter()<<endl; //30 22
    fixRect(r);
    cout<<r.Square()<<ends<<r.Parameter()<<endl;//30 22(不会对实参产生影响)
    FixRect(r);
    cout<<r.Square()<<ends<<r.Parameter()<<endl;//56 30
    return 0;
}

用法四：类的定义和类的成员函数分开写

#include<bits/stdc++.h>
using namespace std;
class Rect
{
    public:
        int w,h;
        int Square(void);
        int Parameter(void);
        void Init(int,int);//函数原型
 };
int Rect::Square(void)//Rect::说明该函数是Rect类的成员函数，不是普通的函数
{
    return w*h;
}
int Rect::Parameter(void)
{
    return 2*(w+h);
}
void Rect::Init(int _w,int _h)
{
    w=_w;
    h=_h;
}
int main(void)
{
    Rect r1,r2,r3;
    Rect *p=&r2;
    Rect &r=r3;
    r1.Init(7,8);//通过对象调用
    p->Init(5,6);//通过对象指针调用
    r.Init(3,4);//通过对象引用调用
    std::cout<<r1.Square()<<ends<<p->Parameter()<<ends<<r3.Square();//56 22 12
    return 0;
}

类成员的可访问范围

注意：若某个成员没有上述关键字，则被缺省地认为是私有成员

#include<bits/stdc++.h>
using namespace std;
class Employee
{
    private:
        string szName;
    public:
        int salary;
        void SetName(string);
        void GetName(void);
        int AverageSalary(Employee &,Employee &);    
};
void Employee::SetName(string name)
{
    szName=name;
}
void Employee::GetName(void)
{
    std::cout<<szName;
}
int Employee::AverageSalary(Employee &e1,Employee &e2)
{
    return (e1.salary+e2.salary)/2;
}
int main(void)
{
    Employee E1,E2;
    E1.salary=5000,E2.salary=10000;
    E1.szName="Tom";//编译出错 main函数不是类成员函数，不可通过其访问类私有成员
    E1.SetName("Tom");//OK 通过公有成员函数SetName访问私有成员变量szName
    E2.SetName("Jerry");//OK
    E1.GetName();//OK 通过公有成员函数SetName访问私有成员变量szName 
    cout<<endl;//Tom
    E2.GetName();//OK
    cout<<endl;//Jerry
    std::cout<<E1.AverageSalary(E1,E2);//7500 该函数同时访问两个同类对象的公有变量salary
    return 0;
}

隐藏机制及其作用

准确地讲，是在SetName()中增加判断是否越界的语句，若越界则删除越界的部分

成员函数的重载和参数缺省

成员函数可以重载，也可以带缺省参数

注意：使用缺省参数时避免函数重载时候的二义性