引文：
以下内容引自高焕堂老师的《》一书。
认识C的对象与类
类的用途
类的目的是﹕创造新数据型态。为那描述自然界的万事万物，必须有各式各样的数据型态，才足以充分贴切地表达自然界的静态与动态的美。C只提供数种基本数据型态，欲表达人类 会或大自然的景象，实在并不足够。
然而C加上“类”(Class)概念之后，就很容易解决这个问题了。它让程序师定义与创造自己心爱的数据型态来描述心中所想的、眼睛所看到的任何自然界景象。
在C里，int、double及char等常称为“基本数据型态”(Fundamental Data Type)﹔藉类而创造出来的数据型态则称为“抽象数据型态”(Abstract Data Type)。“抽象”意谓着﹕类只描述自然事物的重要(Essential)特征和行为，而忽略不重要的细节。于是，有个不成文的规则是﹕
⊙由基本数据型态所宣告的变量，直称为变量。
⊙由抽象数据型态(类)所宣告的变量，特称为对象。
此规则的目的是﹕让已受古典程序熏陶的C程序师，能区别C与OOPC的不同。如果您对软件的认识才刚起步，宜把变量和对象视为同义词，这是OOP的本质，只因C++从C演变而来，担负了新旧传承的任务，才加以区分的。
例如﹕定义类如下﹕
CLASS(Rose)
{
….
};
这Rose就是我们新创的数据型态，将用来生成对象，以描述自然界的玫瑰花。于是可宣告对象如下﹕
Rose a;
pr = RoseNew();
pa是指向对象的指针，*pa的型态是Rose。因对象就是变量，所以其在内存中也占有空间，裨储存数据。
┌───────────────┐
│╭───╮│
│对象a│││(主存储器)
│╰───╯│
││
└───────────────┘
定义类
类是一群具有共同重要特性的对象。类的定义就是说明这群对象具有什么的重要特性。特性包括对象的特征及行为。软件中的对象以数据来表达特征，以函数来表达行为。因此，类的定义就是说明软件中的对象，应含那些数据及那些函数。定义类时，应考虑如下﹕
⊙我们欲描述那些对象﹖
如果欲描述手中的一朵花，而此朵花是一朵(is a)玫瑰花，则可得知手上的花是对象，而玫瑰花是类。为了描述手上的玫瑰花，就得定义类叫Rose。
⊙对象有那些重要特征(Attribute)﹖
如果您想描述其价钱，也想描述其最适合做那月份的生日花﹔则可知Rose类应包含两项重要数据──price和month。于是，就可运用lw_oop.h宏来定义Rose类，并生成对象了，如下﹕
#include “stdio.h”
#include “lw_oopc.h”
CLASS(Rose)
{
float price;
int month;
};
void main()
{
Rose rose;
rose.price = 20.5;
rose.month = 6;
printf(“price= %6.2fn”, rose.price);
printf(“month= %dn”,
rose.month);
getchar();
return 0;
}
此Rose类的对象rose在内存中占了一块空间，内含两个属性──price及month，如下﹕
rose.pricerose.month
╭──────┬──────╮
rose对象│20.5│6│
╰──────┴──────╯
此对象代表手上那朵花，而price和month两个属性描述着该朵花的特征。
如果桌上有一朵花，且它是一朵(is
a)玫瑰花，则它与手上的花属于同一类，可直接拿Rose类来宣告对象，以描述桌上那朵花，如下﹕
#include
#include “stdio.h”
#include “lw_oopc.h”
CLASS(Rose)
{
float price;
int month;
};
void main()
{
Rose rose1, rose2;
rose1.price = 20.5;
rose1.month = 6;
rose2.price = 1.25;
rose2.month = 7;
printf(“%6.1f, %dn”, rose1.price, rose1.month);
printf(“%6.1f, %dn”, rose2.price, rose2.month);
getchar();
return 0;
}
Rose类就像过年过节时，妈妈做“粿”时的“粿印”，同一个模子(Template)可印出许多同样形状的粿。所以Rose是粿印，而*pr1和*pr2是真实可吃的粿。计算机的主存储器就像妈妈用的“蒸笼”﹕
┌──────────────────────────────────┐
│rose1.pricerose1.monthrose2.pricerose2.month│
│╭──────┬──────╮╭──────┬─────╮│
││20.5│6││1.25│6││
│╰──────┴──────╯╰──────┴─────╯│
│rose1对象rose2对象│
└──────────────────────────────────┘
(主存储器)
⊙对象有那些重要行为﹖
前述Rose的特征──month， 并非自然界玫瑰花与生俱来的，而是人们所赋予的情意。所以对象并非单纯地描述自然界天生俱有的特性，也包括人们赋予的抽象涵意。同样地，软件中的对象除了
描述自然界对象的行为外，也会描述人们所赋予的特殊行为。例如，自然界有石头、水牛和太阳，则软件中有石头、水牛和太阳对象来描述的，但软件中的石头会点 头、水牛会弹琴、太阳会撒娇等。这是所谓的“对象人性化”，软件师在创造对象时，可尽情地把对象想象成绝顶聪明的。例如，Rose的对象，可能具有如下行为﹕
◇散发罗曼情意。
◇说出它代表何人的心意。
◇说出它的价钱。
◇正在盛开或凋谢。
◇飞过秋千去。
…..
因此，赋予人性后，Rose的对象将比实际玫瑰花更加罗曼帝克呢﹗假设我们认为Rose的重要行为是──
说出它的颜色
则Rose类应增加一个函数──say()如下﹕
#include “stdio.h”
#include “lw_oopc.h”
CLASS(Rose)
{
float price;
int month;
void (*say)();
};
static void say()
{ printf(“price is REDn”); }
void main()
{
Rose rose;
rose.say = say;
rose.say();
getchar();
return 0;
}
此时Rose类的对象皆具有一项共同行为──说出其颜色。在软件中，靠say()来表达这项行为。
对于指令：rose.say();可解释为：将信息──say()传送给Rose的对象，如﹕
其意义是﹕“请问你是什么颜色呢﹖”，兹以图示如下﹕
say()信息
pricemonth╭──────
╭────┬────╮│
│││←─╯
rose对象├────┴────┤
│say()│
╰─────────╯
当此对象接到信息──say()时，便启动其内含的say()函数，并执行say()函数内的指令。上述Rose的对象已具有一个函数──say()，支持一项重要行为──Rose的对象能输出自己的内容。如果对其它行为有兴趣，可继续增加Rose类的函数，使其对象具有多样化的行为。
对象指针
C所提供的指针可以指向基本数据型态(如float等)的变量。此外，指针也可以指向对象。例如上一小节的程序相当于﹕
#include “stdio.h”
#include “lw_oopc.h”
CLASS(Rose)
{
float price;
int month;
void (*say)();
};
static void say()
{ printf(“price is REDn”); }
void main()
{
Rose rose, *pr;
rose.say = say;
/*—————–*/
pr = &rose;
pr->say();
getchar();
return 0;
}
因为对象是以C结构来实现的，指针可以指向结构变量，所以也能指向对象。此程序的pr正指向rose对象。接下来，进一步看看say()函数如何存取对象的内容。例如：
#include “stdio.h”
#include “lw_oopc.h”
CLASS(Rose)
{
float price;
int month;
void (*say)(Rose*);
};
static void say(Rose* p)
{ printf(“%6.2f, %dn”, p->price, p->month); }
void main()
{
Rose rose, *pr;
rose.price = 38.25;
rose.month = 12;
rose.say = say;
/* ———————– */
rose.say(&rose);
/* ————————*/
pr = &rose;
pr->say(pr);
getchar();
return 0;
}
这个say()就输出rose的内容了。指令：rose.say(&rose)和pr->say(pr)的意义是相同的。
构造器(Constructor)
#include “stdio.h”
#include “lw_oopc.h”
CLASS(Rose)
{
float price;
int month;
void (*say)(Rose*);
};
static void say(Rose* p)
{ printf(“%6.2f, %dn”, p->price, p->month); }
CTOR(Rose)
FUNCTION_SETTING(say, say);
END_CTOR
void main()
{
Rose *pr = (Rose*)RoseNew();
pr->price = 38.25;
pr->month = 12;
pr->say(pr);
getchar();
return 0;
}
CTOR就是Constructor字眼的简写，这个宏里定义了RoseNew()构造器，它会生成Rose的对象，并传回该对象的指针值，型态为void*。将的转为Rose*型态之后存入pr指针变量里。
类设计的实例说明
以电灯(Light)类为例
基于前面所介绍的lw_oopc.h宏，就可以定义出类了，例如定义一个Light类，其light.h内容为：
/* cx11-lig.h
*/
#include
“lw_oopc.h”
CLASS(Light)
{
void
(*turnOn)();
void
(*turnOff)();
};
类里的函数定义格式为：
回传值的型态(*函数名称)();
类定义好了，就开始编写函数的实现内容：
/*
cx11-lig.c */
#include “stdio.h”
#include
“cx11-lig.h”
static void turnOn()
{
printf(“Light is ONn”); }
static void turnOff()
{
printf(“Light is OFFn”); }
CTOR(Light)
FUNCTION_SETTING(turnOn, turnOn)
FUNCTION_SETTING(turnOff, turnOff)
END_CTOR
这个FUNCTION_SETTING(turnOn, turnOn)宏的用意是：让类定义(.h文件)的函数名称能够与实现的函数名称不同。例如在light.c里可写为：
static void
TurnLightOn()
{….. }
CTOR(Light)
{
FUNCTION_SETTING(turnOn,
TurnLightOn);
…..
}
这是创造.c档案自由抽换的空间，这是实践接口的重要基础。最后看看如何编写主程序：
/*
cx11_ap1.c */
#include “stdio.h”
#include
“cx11-lig.h”
extern void* LightNew();
void main()
{ Light* light =
(Light*)LightNew();
light->turnOn();
light->turnOff();
getchar();
return;
}
LightNew()是由CTOR宏所生成的类构造器(Constructor)。由于它是定义于别的档案，所以必需加上extern
void* LightNew();指令。生成对象的基本格式为：
类名称*对象指针= (类名称*)类名称New();
示例：Light* light = (Light*)LightNew()
LightNew()构造器生成新对象，light是对象指针，它就指向此对象。然后就透过light指标去调用成员函数了。
下面介绍在上段内容中所提及到的#include “lw_oopc.h”
#ifndef
LOOPC_H
#define
LOOPC_H
#include
#define
CLASS(type)
typedef
struct type type;
struct
type
#define
CTOR(type)
void*
type##New()
{
struct type *t;
t = (struct type *)malloc(sizeof(struct
type));
#define
CTOR2(type, type2)
void*
type2##New()
{
struct type *t;
t = (struct type *)malloc(sizeof(struct
type));
#define
END_CTOR return (void*)t;};
#define
FUNCTION_SETTING(f1, f2)t->f1 = f2;
#define
IMPLEMENTS(type) struct type type
#define
INTERFACE(type) struct type
#endif
在上面所用的代码：
CLASS(Rose)
{
float price;
int month;
void (*say)(Rose*);
};
我们展开如下：
typedef struct Rose Rose;
struct Rose
{
float price;
int month;
void (*say)(Rose*);
};
经过CLASS宏，我们创建了一个Rose结构体，这个结构体包含成员变量price和month，以及一个函数指针，参数为一个Rose对象指针。
CTOR(Rose)
FUNCTION_SETTING(say, say);
END_CTOR
我们展开如下：
void* RoseNew()
{
struct
Rose *t;
t
= (struct Rose *)malloc(sizeof(struct Rose));
t->say = say;
return (void *)t; }
经过这几个宏之后上述代码被展开成一个函数，这个函数创建了一个Rose对象，并且为这个Rose对象分配了内存空间，同时初始化了他的成员函数的函数指针指向。
文章知识点与官方知识档案匹配，可进一步学习相关知识C技能树首页概览113895 人正在系统学习中 相关资源：桌面开满999朵玫瑰花软件绿色版.rar-其它代码类资源-CSDN文库
声明：本站部分文章及图片源自用户投稿，如本站任何资料有侵权请您尽早请联系jinwei@zod.com.cn进行处理,非常感谢！