第十章 定义类笔记

10.1

1.结构体

struct a{
    int b;
    double c;
};

结构体放在函数定义的外部，定义好之后，能被所有代码调用
调用结构体成员

    a a1;
    a1.b=1;
    a1.c=2.3;

结构体允许两个不同的结构体成员名称一致

struct a{
    int b;
    double c;
};
struct aa{
    int b;
    double c;
};

注意，结构体的定义后有分号
函数可以用结构类型来传值的
结构体的初始化：

a a2 = { 1 , 2.5 };

赋值顺序必须于结构体中定义顺序一致

2类
类是数据类型，其变量是对象。

class a{
public:
    void out();
    int b;
    double c;
};
int main()
{
}

void a::out(){
    cout << b <<endl;
    cout << c <<endl;
}

类的定义与结构体类似，仅仅知识关键字不同。
void a::out()中::是作用域解析操作符，out()方法中直接使用的是成员名称，没有具体对象，但是调用之后会自动转换为对象
公告成员和私有成员，public和private
private定义的内容，只有该类能够访问，其他成员调用均为非法

class a{
public:
    void out();
    int b;
private:
    double c;
};

类a中的成员变量c只有类a中的out()方法能够调用
封装也称为数据隐藏，目的是使类中的变量私有化，只能通过该类的public和protected修饰的接口来访问
没有修饰时类默认所有为private
以下面代码为例

#include "stdafx.h"
#include <iostream> 
using namespace std; 
//typedef int* Int;
class BankAccount{
public:
    //带美分
    void set(int dollars,int cents,double rate);
    //不带美分
    void set(int dollars,double rate);
    //将一年的利息加到余额上
    void update();
    //返回余额
    double getBalance();
    double getRate();
    void output(ostream& outs);
private:
    //总存款
    double balance;
    //利率
    double inRate;
    //将百分比转换为小数,辅助函数
    double fraction(double percent);
};
int main()
{
    BankAccount a1,a2;
    a1.set(123,65,3.0);
    a1.output(cout);
    a2.set(100,5.0);
    a2.output(cout);
    a1.update();
    a1.output(cout);

}

void BankAccount::set(int dollars,int cents,double rate){
    balance = dollars + 0.01*cents;
    inRate = rate;
}
void BankAccount::set(int dollars,double rate){
    balance = dollars;
    inRate = rate;
}
void BankAccount::update(){
    balance = balance + fraction(inRate)*balance;
}
double BankAccount::fraction(double pValue){
    return(pValue/100.0);
}
double BankAccount::getBalance(){
    return balance;
}
double BankAccount::getRate(){
    return inRate;
}
void BankAccount::output(ostream& outs){
    outs.setf(ios::fixed);
    outs.setf(ios::showpoint);
    outs.precision(2);
    cout<<balance<<endl;
    cout<<inRate<<endl;
}

代码布局，类在主函数上方，public修饰方法函数，也就是接口，private修饰成员变量和辅助函数，类中的函数只写函数名，函数的实现在主函数之后写
类的一些特征：
类具有成员变量和成员函数
成员可为共有或私有
通常，类的成员变量都应该是私有的
类的私有成员只能由类的函数调用
类的函数可以重载
一个类可以被另一个类作为成员变量的类型使用
类可以使函数返回的类型

构造函数，构造函数是用来初始化类的成员变量的，构造函数必须与类同名，且一定不能有返回值，一般来讲构造函数应设为public类型
以上图的代码为例，进行修改

//在类里定义
BankAccount(int dollars,int cents,double rate);
//实现
void BankAccount::BankAccount(int dollars,int cents,double rate){
    balance = dollars + 0.01*cents;
    inRate = rate;
}

赋值操作

BankAccount a1(999,25,0.3);

通常来讲构造函数是有多个的，方便重载

构造函数初始化区域初始化所有成员函数

void BankAccount::BankAccount(int dollars,int cents,double rate): balance(dollars + 0.01*cents) , inRate(rate){
}

3抽象数据类型

抽象数据类型(Anstract Data Type, ADT)，不能访问成员变量和辅助函数，只能通过调动类的接口函数(public修饰的函数)来间接调用，比如int类型，你不知道+，-，/，*是怎么实现的，，但是你能用

定义一个抽象数据类型的类,这里直接用来上面的代码

class BankAccount{
public:
    BankAccount(int dollars,int cents,double rate);
    void set(int dollars,int cents,double rate);
    void set(int dollars,double rate);
    void update();
    double getBalance();
    double getRate();
    void output(ostream& outs);
private:
    double balance;
    double inRate;
    double fraction(double percent);
};

由以上可看出，ADT类特点
所有的成员变量和辅助函数都是private，基本外部要调用的函数(即接口)都是public

4继承

这里简略的介绍了继承的基本概念，更多内容在第十五章