类的声明
class 类名称
{
public:
公有成员(外部接口)
private:
私有成员
protected:
保护成员
};
/*Clock.h
*实现简单的时钟类，变量包括时分秒
*/
#ifndef _CLOCK_H
#define _CLOCK_H
class Clock
{
public:
void Display(); //显示时分秒
void Init(int hour,int minute,int second);//输入时间
void Update(); //更新时间
int getHour_(); //得到时
int getMinute_(); //分
int getSecond_(); //秒
void setHour_(int hour); //输入 时
void setMinute_(int minute); //分
void setSecond_(int second); //秒
private:
int hour_;
int minute_;
int second_;
};
#endif/*Clock.cpp
*各函数的具体实现
*/
#include "Clock.h"
using namespace std;
void Clock::Display()
{
cout << hour_ << ":" << minute_ << ":" << second_ << endl;
}
void Clock::Init(int hour,int minute,int second)
{
hour_ = hour;
minute_ = minute;
second_ = second;
}
void Clock::Update()
{
second_ ++;
if(second_ == 60)
{
minute_ ++;
second_ = 0;
}
if(minute_ == 60)
{
hour_ ++;
minute_ = 0;
}
if(hour_ == 24)
{
hour_ = 0;
}
}
int Clock::getHour_()
{
return hour_;
}
int Clock::getMinute_()
{
return minute_;
}
int Clock::getSecond_()
{
return second_;
}
void Clock::setHour_(int hour)
{
hour_ = hour;
}
void Clock::setMinute_(int minute)
{
minute_ = minute;
}
void Clock::setSecond_(int second)
{
second_ = second;
}#include "Clock.h"
//using namespace std;
int main()
{
Clock c;
c.Init(10,10,10);
c.Display();
/*当把变量设为私有后,外部函数不能访问该变量*/
//c.second_ += 1;
/*定义接口函数*/
c.Update();
/*访问变量*/
c.Display();
//c.getMinute_();
c.setHour_(12);
c.Display();
return 0;
}公有、私有、保护成员
public:它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数
private:只允许本类中的函数访问，而类外部的函数不能访问
protected:与private类似，其差别表现在继承与派生时对派生类的影响不同
数据抽象和封装
类设计者必须关心类是如何实现的；使用者只要抽象地考虑该类型做什么，而不必具体地考虑该类内部是怎么实现的，只要类所提供的接口不变，那么对类使用者所写的代码就是稳定的。
封装是一项将低层次的元素组合起来形成更高层次的实体的技术。函数是封装的一种形式：函数所执行的细节行为被封装在函数这个更大的实体中。被封装的元素隐藏了它们的实现细节－－可以调用函数，但是不能直接访问函数所执行的语句。类也是一个封装的实体：它代表若干成员的聚集，设计良好的类隐藏了类实现的细节。
内联成员函数
内联函数的两种实现方式：
1.在成员函数具体实现时，在返回类型前加 **inline** 关键字
/*Test.cpp*/
#include "Test.h"
using namespace std;
inline int Test::Add(int a,int b)
{
return a + b;
}2.直接在类体中给出实现
class Test{
public: //内联函数第二种定义方式
int Add(int a,int b)
{
return a + b;
}
};成员函数的重载
/*类的声明*/
#ifndef _TEST_H
#define _TEST_H
class Test{
public:
/*构成重载*/
void Init();
void Init(int x);
void Init(int x,int y);
void Init(int x,int y,int z);
void Display();
private:
int x_;
int y_;
int z_;
};
#endif/*成员函数的具体实现*/
void Test::Init()
{
x_ = 0;
y_ = 0;
z_ = 0;
}
void Test::Init(int x)
{
x_ = x;
y_ = 0;
z_ = 0;
}
void Test::Init(int x,int y)
{
x_ = x;
y_ = y;
z_ = 0;
}
void Test::Init(int x,int y,int z)
{
x_ = x;
y_ = y;
z_ = z;
}
void Test::Display()
{
cout << "x=" << x_ << endl;
cout << "y=" << y_ << endl;
cout << "z=" << z_ << endl;
}/*主函数*/
#include "Test.h"
using namespace std;
int main()
{
Test t;
t.Init();
t.Display();
t.Init(10);
t.Display();
return 0;
}/*输出：*/
x=0
y=0
z=0
x=10
y=0
z=0附：成员函数可以有默认缺省值
class 与 struct 的区别
在未指定访问权限时，class默认的是私有的，struct 默认是公有的
struct Test1
{
int x_;
int y_;
void Init(int x,int y)
{
x_ = x;
y_ = y;
}
void Display()
{
cout << x_ << "," << y_ <<endl;
}
};
class Test2
{
int x_;
int y_;
void Init(int x,int y)
{
x_ = x;
y_ = y;
}
void Display()
{
cout << x_ << "," << y_ <<endl;
}
};
int main()
{
Test1 test1;
Test2 test2;
/*结构体*/
test1.Init(10,10);
test1.Display();
/*类--默认是私有 所以error*/
//test2.Init(20,20);
//test2.Display();
return 0;
}前向声明
C++ 中类必须先定义，才能够实例化。
两个类需要相互引用形成一个"环形"引用时，无法先定义使用。这时候需要用到前向声明。
#ifndef _前向声明A_H
#define _前向声明A_H
#include "前向声明B.h" //用到B类对象所以包含头文件
class A
{
public:
A(void);
^A(void);
B b_;
};
#endif/*A.h用到B.h,B.h也用到A.h，这是错误的,这时候就要用到前向声明*/
#ifndef _前向声明B_H
#define _前向声明B_H
//#include "前向声明A.h" 前向声明后，头文件不需要包含头文件
class A;
class B
{
public:
B(void);
^B(void);
/*类B中也用到A类对象，这就是环形引用*/
A a_;//error :不能实例化对象,也不能用作参数,能定义指针或引用
};
#endif局部类(一般很少使用)
1.类也可以定义在函数体内，这样的类称为局部类。
2.局部类只在定义它的局部域内可见
3.局部类只能在定义它的函数内部实现和使用，即在函数内有效
4.局部类内部不能定义静态成员。
void Fun()
{
class LocalClass
{
public:
int num_;
void Init(int num)
{
num_ = num;
}
void Display()
{
cout << num_ << endl;
}
static int num2_; //error 局部类内不能定义静态成员
};
/*函数体内部使用*/
LocalClass lc;
lc.Init(10);
lc.Display();
}
int main()
{
Fun();
//LocalClass lc; error 局部类只能在函数体中使用
return 0;
}