C语言面向对象

简介: C语言面向对象

我们在编写程序时,通常采用以下步骤:

  1. 将问题的解法分解成若干步骤
  2. 使用函数分别实现这些步骤
  3. 依次调用这些函数

这种编程风格的被称作面向过程。除了面向过程之外,还有一种被称作面向对象的编程风格被广泛使用。面向对象采用基于对象的概念建立模型,对现实世界进行模拟,从而完成对问题的解决。

C语言的语法并不直接支持面向对象风格的编程。但是,我们可以通过额外的代码,让C语言实现一些面向对象特性。在这一节当中,我们将探究什么是面向对象,以及怎样用C语言来实现它。

单纯理论上的讨论可能比较难以理解,为了能够让我们的讨论能够落地到实际中,我们选取学校为场景,展开对面向对象风格编程的讨论。

一般而言面向对象风格的编程具有以下3大特性:

  • 封装
  • 继承
  • 多态

我们将以这3个特性为线索,讨论C语言如何面向对象编程。

封装

我们来看看学校里面最重要的主体是什么?是学生。学生肯定拥有很多属性,比如学生的学号、姓名、性别、考试分数等等。自然地,我们会声明一个结构体用于表示学生。

struct student {
  int id; // 学号
  char name[20]; // 姓名
  int gender; // 性别
  int mark; // 成绩
};

学生的学号由 入学年份 、 班级 、 序号 拼接构成。

例如,某一个同学的是 2022 年入学的 123 班的 26 号学生。那么,它的学号为 202212326 。

为了方便设置学号,我们有一个 makeStudentId 函数,参数为 入学年份 、 班级 、 序号 ,它将这些数据拼接成字符串,再将字符串转换为整型数据,最后将这个整型数据作为学生的 id 并返回。

int makeStudentId(int year, int classNum, int serialNum)
{
  char buffer[20];
  sprintf(buffer, "%d%d%d", year, classNum, serialNum);
  int id = atoi(buffer);
  return id;
}

sprintfprintf函数类似,printf函数会将占位符"%d%d%d"替换为其后的参数,将结果打印到控制台上。而sprintf不会将结果打印在控制台上,而是将结果存放在第一个参数buffer所指示的字符数组当中。

函数atoi能将buffer指示的字符串转换为整型并返回结果。

性别在结构体中存储为整型数值,0代表女生、1代表男生。而显示时,我们希望0显示为1显示为。因此,还需要有一对用于操作性别的函数。在函数命名中,使用numGender代表使用整型表示的性别。strGender代表使用字符串表示的性别。

我们将定义两个函数:

numGenderToStrGender表示,将整型表示的性别转换为字符串表示的性别。

strGenderToNumGender表示,将字符串表示的性别转换为整型表示的性别。

const char* numGenderToStrGender(int numGender)
{
  if (numGender == 0)
  {
    return "女";
  }
  else if (numGender == 1)
  {
    return "男";
  }
  return "未知";
}
int strGenderToNumGender(const char* strGender)
{
  int numGender;
  if (strcmp("男", strGender) == 0)
  {
    numGender = 1;
  }
  else if (strcmp("女", strGender) == 0)
  {
    numGender = 0;
  }
  else
  {
    numGender = -1;
  }
  return numGender;
}

我们将使用以下方式,调用这个结构体和这3个函数。

int main()
{
  struct student stu;
  // 设置数值
  // 学号:202212326
  // 姓名:小明
  // 性别: 男
  // 成绩:98
  stu.id = makeStudentId(2022, 123, 26);
  strcpy(stu.name, "小明");
  stu.gender = strGenderToNumGender("男");
  stu.mark = 98;
  // 打印这些数值
  printf("学号:%d\n", stu.id);
  printf("姓名:%s\n", stu.name);
  const char* gender = numGenderToStrGender(stu.gender);
  printf("性别:%s\n", gender);
  printf("分数:%d\n", stu.mark);
  return 0;
}

现在,我们使用面向过程风格写了3个函数和一个结构体,并且调用了这些函数,将函数返回的结果赋值给了结构体。接下来,让我们以面向对象风格来重新审视这段代码。

在面向对象风格中,结构体被看做数据(data),而操作数据的函数称作方法(method)。目前函数和数据是分离的,函数并不直接操作数据,我们需要拿到函数返回的结果,再将其赋值给数据。面向对象风格编程的第一大特性——封装,它希望方法直接操作数据,并且将数据和方法结合在一起,它们构成一个整体。而这个整体被称作对象

此外,还有一个方法命名上的规则。一般来说,获取数据的方法会被命名为getXXX,设置数据的方法会被命名为setXXX

我们对这3个函数做如下修改:

  1. 将函数的第一个参数设置为struct student *,让函数直接操作student结构体。
  2. 修改函数名,获取数据的方法命名为getXXX,设置数据的方法命名为setXXX
void setStudentId(struct student* s, int year, int classNum, int serialNum)
{
  char buffer[20];
  sprintf(buffer, "%d%d%d", year, classNum, serialNum);
  int id = atoi(buffer);
  s->id = id;
}
const char* getGender(struct student* s)
{
  if (s->gender == 0)
  {
    return "女";
  }
  else if (s->gender == 1)
  {
    return "男";
  }
  return "未知";
}
void setGender(struct student* s, const char* strGender)
{
  int numGender;
  if (strcmp("男", strGender) == 0)
  {
    numGender = 1;
  }
  else if (strcmp("女", strGender) == 0)
  {
    numGender = 0;
  }
  else
  {
    numGender = -1;
  }
  s->gender = numGender;
}

现在,我们用修改后的函数,直接操作student结构。

int main()
{
  struct student stu;
  // 学号:202212326
  // 姓名:小明
  // 性别: 男
  // 分数:98
  setStudentId(&stu, 2022, 123, 26);
  strcpy(stu.name, "小明");
  setGender(&stu, "男");
  stu.mark = 98;
  // 打印这些数值
  printf("学号:%d\n", stu.id);
  printf("姓名:%s\n", stu.name);
  const char* gender = getGender(&stu);
  printf("性别:%s\n", gender);
  printf("分数:%d\n", stu.mark);
}

目前,函数可以直接操作数据了。但是,函数和数据依然是两个独立的部分。我们要将函数和数据结合到一起,这样,这个整体就能被称作对象,函数可以称作属于这个对象的方法

大多数面向对象语言都提供了以下的格式调用一个对象的方法。

对象.方法(对象指针,参数1,参数2, 参数3...)

接下来,我们举几个这种格式的例子:

stu.setGender(&stu, "男");

以上代码中,对象为stu,方法为setGender。通过对象 + 点 + 方法的形式,可以调用属于对象stusetGender方法。在方法的参数中传入性别。这样,方法会把性别转换为整形,并设置到对象stu的数据当中。

const char* gender = stu.getGender(&stu);

以上代码中,对象为stu,方法为getGender。通过对象 + 点 + 方法的形式,可以调用属于对象stugetGender方法。getGender方法从对象数据中获取整形表示的性别,并返回性别对应的字符串。

在C语言中,若要实现对象 + 点 + 方法的形式,我们可以借助于函数指针。

在结构中,声明这3个函数的函数指针。

struct student {
  void (*setStudentId)(struct student* s, int year, int classNum, int serialNum);
  const char* (*getGender)(struct student* s);
  void (*setGender)(struct student* s, const char* strGender);
  int id; // 学号
  char name[20]; // 姓名
  int gender; // 性别
  int mark; // 分数
};

为了让函数指针有正确的指向,我们需要通过一个initStudent函数,为结构体初始化。

void initStudent(struct student* s)
{
  s->setStudentId = setStudentId;
  s->getGender = getGender;
  s->setGender = setGender;
}

现在,我们可以使用对象 + 点 + 方法的形式,调用对象的方法了。

struct student stu;
// 初始化student
initStudent(&stu);
// 学号:202212326
// 姓名:小明
// 性别: 男
// 分数:98
stu.setStudentId(&stu, 2022, 123, 26);
strcpy(stu.name, "小明");
stu.setGender(&stu, "男");
stu.mark = 98;
// 打印这些数值
printf("学号:%d\n", stu.id);
printf("姓名:%s\n", stu.name);
const char* gender = stu.getGender(&stu);
printf("性别:%s\n", gender);
printf("分数:%d\n", stu.mark);

这里有一个需要注意的地方,结构体声明后,结构体内的函数指针是无效的。必须先调用initStudent函数,将其设置正确的指向,才能使用这些函数指针。否则,将有可能导致程序崩溃。

为了让方法修改或访问对象,方法的参数中必须要有对象的指针。实现的形式中,第一个参数就是被操作对象指针。其它语言中,被操作对象指针是隐式传递的。不需要你在传参时写明参数,它会自动传入函数。例如,C++中会自动将一个名为this的对象指针作为方法的参数。而C语言中,无法做到自动将对象的指针传入方法,所以我们需要手动写上需要操作的对象的指针。

// C++的写法
stu.setGender("男");
// C语言的写法
stu.setGender(&stu, "男");

继承

除了学生之外,学校里面还需要有老师,老师也具有很多属性。例如:

  • 工号
  • 姓名
  • 性别
  • 任课科目

声明一个结构体用于表示老师。

struct teacher {
  int id; // 工号
  char name[20]; // 姓名
  int gender; // 性别
  char subject[20]; // 任课科目
};

比较一下学生和老师的结构体,看看它们之间有什么共同之处与不同之处。

struct teacher {
  int id; // 工号
  char name[20]; // 姓名
  int gender; // 性别
  char subject[20]; // 任课科目
};
struct student {
  int id; // 学号
  char name[20]; // 姓名
  int gender; // 性别
  int mark; // 分数
};

共同之处如下:

  • 编号
  • 姓名
  • 性别

不同之处:

  • 学生有考试分数
  • 老师有任课科目

我们可以把两个结构体中的共同之处抽象出来,让它共同之处成为一个新的结构。这个结构体具有老师和学生的共性,而老师与学生它们都是人,可以把这个结构体命名为person

struct person {
  int id; // 编号
  char name[20]; // 姓名
  int gender; // 性别
};

接下来,我们可以让老师和学生结构包含这个person对象。

struct teacher {
  struct person super;
  char subject[20]; // 任课科目
};
struct student {
  struct person super;
  int mark; // 分数
};

让我们比较一下原有代码与现有代码。

原有代码:

// 原有代码
struct teacher {
  int id; // 工号
  char name[20]; // 姓名
  int gender; // 性别
  char subject[20]; // 任课科目
};
struct student {
  int id; // 学号
  char name[20]; // 姓名
  int gender; // 性别
  int mark; // 分数
};

现有代码

// 现有代码
struct person {
  int id; // 编号
  char name[20]; // 姓名
  int gender; // 性别
};
struct teacher {
  struct person super;
  char subject[20]; // 任课科目
};
struct student {
  struct person super;
  int mark; // 分数
};

原有代码中,老师和学生结构体中,均有idnamegender三个变量。现有代码中,将这3个变量抽象成结构体person。这样一来,有两个好处:

  1. 减少重复代码
  2. 代码层次更清晰

由于studentteacher拥有person的一切,因此,我们可以说,studentteacher继承personpersonstudentteacher父对象studentteacherperson子对象

刚刚我们只讨论了数据,现在我们结合上方法一起讨论。

struct person {
  int id; // 编号
  char name[20]; // 姓名
  int gender; // 性别
};
struct teacher {
  struct person super;
  char subject[20]; // 任课科目
};
struct student {
  struct person super;
  int mark; // 分数
  void (*setStudentId)(struct student* s, int year, int classNum, int serialNum);
  const char* (*getGender)(struct student* s);
  void (*setGender)(struct student* s, const char* strGender);
};

之前我们为student写了3个方法

  • 设置性别
  • 获取性别
  • 设置学号

其中,性别相关的方法也属于共性的方法。可以把这两个函数指针移动到person对象里面去,注意,要把方法的第一个参数struct student *修改为struct person *。移动后,子对象studentteacher均可以使用这一对性别相关的方法。而设置学号的方法,为student独有的方法,因此保持不变,依然将其放置在student对象内。

struct person {
  int id; // 编号
  char name[20]; // 姓名
  int gender; // 性别
  // 设置性别
  void (*setGender)(struct person* s, const char* strGender);
  // 获取性别
  const char* (*getGender)(struct person* s);
};
struct teacher {
  struct person super;
  char subject[20]; // 任课科目
};
struct student {
  struct person super;
  int mark; // 分数
  // 设置学号
  void (*setStudentId)(struct student* s, int year, int classNum, int serialNum);
};

对应上面的更改,函数getGendersetGender的第一个参数也要由struct student *修改为struct person *

const char* getGender(struct person* p)
{
  if (p->gender == 0)
  {
    return "女";
  }
  else if (p->gender == 1)
  {
    return "男";
  }
  return "未知";
}
void setGender(struct person* p, const char* strGender)
{
  int numGender;
  if (strcmp("男", strGender) == 0)
  {
    numGender = 1;
  }
  else if (strcmp("女", strGender) == 0)
  {
    numGender = 0;
  }
  else
  {
    numGender = -1;
  }
  p->gender = numGender;
}

此外,setStudentId函数中,id成员,不在student中,而是在student中的person中。这里也要对应的修改一下。

void setStudentId(struct student* s, int year, int classNum, int serialNum)
{
  char buffer[20];
  sprintf(buffer, "%d%d%d", year, classNum, serialNum);
  int id = atoi(buffer);
  s->super.id = id; // 由s->id = id 修改为 s->super.id = id
}

还有,别忘了给结构初始化函数指针。

void initPerson(struct person* p)
{
  p->getGender = getGender;
  p->setGender = setGender;
}
void initStudent(struct student* s)
{
  initPerson(&(s->super));
  s->setStudentId = setStudentId;
}
void initTeacher(struct teacher* t)
{
  initPerson(&(t->super));
}

下面我们即可使用这些对象了。

struct student stu;
// 初始化student
initStudent(&stu);
// 学号:202212326
// 姓名:小明
// 性别: 男
// 分数:98
stu.setStudentId(&stu, 2022, 123, 26);
strcpy(stu.super.name, "小明");
stu.super.setGender(&stu.super, "男");
stu.mark = 98;
// 打印这些数值
printf("学号:%d\n", stu.super.id);
printf("姓名:%s\n", stu.super.name);
const char* gender = stu.super.getGender(&stu.super);
printf("性别:%s\n", gender);
printf("分数:%d\n", stu.mark);
putchar('\n');
struct teacher t;
// 初始化teacher
initTeacher(&t);
// 工号:12345
// 姓名:林老师
// 性别: 男
// 科目:C语言
t.super.id = 12345;
strcpy(t.super.name, "林老师");
t.super.setGender(&t.super, "男");
strcpy(t.subject, "C语言");
// 打印这些数值
printf("学号:%d\n", t.super.id);
printf("姓名:%s\n", t.super.name);
gender = t.super.getGender(&t.super);
printf("性别:%s\n", gender);
printf("科目:%s\n", t.subject);

多态

我们以绘制各种图形为背景,展开对多态这一特性的讨论。

绘制图形

现在,我们有3种图形,它们分别为:

  • 矩形
  • 圆形
  • 三角形

我们把这3种图形均看做对象,这些图形对象,分别需要有哪些属性呢?

  • 矩形:左上角坐标、右下角坐标
  • 圆形:圆心x坐标、圆心y坐标、半径
  • 三角形:三个顶点坐标

现在,我们用代码分别实现这几个对象。

struct Rect {
  int left;
  int top;
  int right;
  int bottom;
};
struct Circle {
  int x;
  int y;
  int r;
};
struct Triangle {
  POINT p1;
  POINT p2;
  POINT p3;
};

为了能够在屏幕上绘制这些图形,每个图形都设置一个名为draw的方法。

struct Rect {
  void (*draw)(struct Rect*);
  int left;
  int top;
  int right;
  int bottom;
};
struct Circle {
  void (*draw)(struct Circle*);
  int x;
  int y;
  int r;
};
struct Triangle {
  void (*draw)(struct Triangle*);
  POINT p1;
  POINT p2;
  POINT p3;
};

分别实现3个不同的绘制函数。

绘制矩形:

调用 easyx 中的 rectangle 函数,传入左上角坐标与右下角坐标。

void drawRect(struct Rect* r)
{
  rectangle(r->left, r->top, r->right, r->bottom);
}

绘制圆形:

调用 easyx 中的 circle 函数,传入圆心坐标与半径。

void drawCircle(struct Circle* c)
{
  circle(c->x, c->y, c->r);
}

绘制三角形:

调用 easyx 中的 line 函数,分别绘制点 p1 到 p2 的线段, p2 到 p3 的线段,以及 p3 到 p1 的线段。

void drawTriangle(struct Triangle* t)
{
  line(t->p1.x, t->p1.y, t->p2.x, t->p2.y);
  line(t->p2.x, t->p2.y, t->p3.x, t->p3.y);
  line(t->p3.x, t->p3.y, t->p1.x, t->p1.y);
}

下面,分别写3个初始化函数,用于给对象中的函数指针draw进行赋值。

void initRect(struct Rect* r)
{
  r->draw = drawRect;
}
void initCircle(struct Circle* r)
{
  r->draw = drawCircle;
}
void initTriangle(struct Triangle* r)
{
  r->draw = drawTriangle;
}

现在,准备工作都做好了,我们开始绘制这些图形吧。

int main()
{
  initgraph(800, 600);
  setaspectratio(1, -1);
  setorigin(400, 300);
  setbkcolor(WHITE);
  setlinecolor(BLACK);
  cleardevice();
  struct Rect r = { -200, 200, 200, 0 };
  struct Circle c = { 0, 0, 100 };
  struct Triangle t = { {0, 200}, {-200, 0}, {200, 0} };
  initRect(&r);
  initCircle(&c);
  initTriangle(&t);
  r.draw(&r);
  c.draw(&c);
  t.draw(&t);
  getchar();
  closegraph();
  return 0;
}

创建一个800 * 600的绘图窗体,设置x轴正方向为从左到右,y轴正方向为从下到上。将原点坐标从窗体左上角更改为窗体中心。设置背景颜色为白色,描边颜色为黑色,并使用背景色刷新整个窗体。下面分别声明矩形、圆形、三角形三个对象,并将需要的属性初始化。之后,三个对象分别调用各自的init函数,为对象内的函数指针赋值。完成准备工作后,即可使用对象 + 点 + 方法的形式,调用各自的draw方法绘制图形了。

多态

struct Rect {
  void (*draw)(struct Rect*);
  int left;
  int top;
  int right;
  int bottom;
};
struct Circle {
  void (*draw)(struct Circle*);
  int x;
  int y;
  int r;
};
struct Triangle {
  void (*draw)(struct Triangle*);
  POINT p1;
  POINT p2;
  POINT p3;
};

我们仔细观察这3个对象,看看它们分别有什么共性?可以发现,这3个对象,它们都有一个draw方法。那么,我们可以将draw这个方法抽象出来,单独放置到一个对象当中。由于这三个对象都是形状。我们可以把单独抽象出来的对象,命名为shapeshape对象中的draw方法,应当是一个共性的方法,所以,它的参数应当设置为struct Shape *

struct Shape {
  void (*draw)(struct Shape*);
};

接下来,让RectCircleTriangle三个对象分别都包含Shape对象。这样,它们就都能使用draw这个方法了。

struct Rect {
  struct Shape super;
  int left;
  int top;
  int right;
  int bottom;
};
struct Circle {
  struct Shape super;
  int x;
  int y;
  int r;
};
struct Triangle {
  struct Shape super;
  POINT p1;
  POINT p2;
  POINT p3;
};

这里有一个需要注意的地方,父对象与子对象的内存排布必须重合

例如:下图中,上面的两个对象内存排布可以重合。而下面的两个对象的内存排布无法重合。

像下面一样的声明Rect是正确的。

// 正确
struct Rect {
  struct Shape super;
  int left;
  int top;
  int right;
  int bottom;
};

而下面一样的声明Rect是错误的。

// 错误
struct Rect {
  int left;
  int top;
  int right;
  int bottom;
  struct Shape super;
};

接着,我们需要修改各对象的初始化函数。将原有的r->draw改为r->super.draw

void initRect(struct Rect* r)
{
  r->super.draw = drawRect;
}
void initCircle(struct Circle* c)
{
  c->super.draw = drawCircle;
}
void initTriangle(struct Triangle* t)
{
  t->super.draw = drawTriangle;
}

注意,这里还有一个问题,函数内赋值运算符左边的函数指针r->super.draw的类型为void (*)(struct Shape*),参数为struct Shape*。而赋值运算符右边的函数指针类型分别为:

void (*)(struct Rect*)
void (*)(struct Circle*)
void (*)(struct Triangle*)

函数指针参数类型不一致,无法进行赋值。我们可以把右边的函数指针强制类型转换为void (*)(struct Shape*)

void initRect(struct Rect* r)
{
  r->super.draw = (void (*)(struct Shape*))drawRect;
}
void initCircle(struct Circle* c)
{
  c->super.draw = (void (*)(struct Shape*))drawCircle;
}
void initTriangle(struct Triangle* t)
{
  t->super.draw = (void (*)(struct Shape*))drawTriangle;
}

我们考虑一下怎样来使用这些对象。

struct Rect r = { {}, - 200, 200, 200, 0 };
struct Circle c = { {}, 0, 0, 100 };
struct Triangle t = { {}, {0, 200}, {-200, 0}, {200, 0} };

首先,声明RectCircleTriangle这3个对象,并使用初始化列表将其初始化。注意,由于它们的第一个成员为super,所以,这里使用空列表{},将super成员初始化为零。

initRect(&r);
initCircle(&c);
initTriangle(&t);

让三个对象分别调用各自的初始化函数,给各自对象super成员中的draw设置为各自对应的绘图函数。

  • r.super.draw设置为drawRect
  • c.super.draw设置为drawCircle
  • t.super.draw设置为drawRTriangle
struct Shape* arrShape[3] = {
(struct Shape*)&r, (struct Shape*)&c, (struct Shape*)&t };

声明一个元素类型为struct Shape *的数组,元素个数为3。分别用r的指针,c的指针,t的指针初始化。注意,这里也需要进行强制类型转换,否则初始化列表里面的指针类型和数组元素的指针类型不一致。

for (int i = 0; i < 3; i++)
{
  arrShape[i]->draw(arrShape[i]);
}

到了关键的一步,使用循环,依次调用draw函数。由于3次循环中的draw函数分别为各个图形各自的绘图函数。所以,虽然统一调用的是draw,但是,却可以执行它们各自的绘图函数。至此,不同实现的方法,在此得到统一。

总结实现多态的步骤

  1. 抽离出各个对象中共有的方法draw,将其单独放置在一个对象Shape内。
  2. 各个对象均继承于Shape对象。
  3. 将各个子对象中的draw方法,设置为各自的实现方法。
  4. 声明一个Shape对象的指针,并将其赋值为一个子对象的指针。
  5. 通过上述对象指针,调用方法共有方法draw,执行的是第三步中设置的方法。
目录
相关文章
|
6月前
|
C语言 iOS开发 MacOS
Objective-C是一种面向对象的编程语言,它扩展了C语言,添加了面向对象编程的特性
【5月更文挑战第9天】Objective-C是苹果公司的面向对象编程语言,用于iOS和macOS应用开发。它扩展了C语言,包含类定义(接口和实现)、对象创建、消息传递、属性、协议、块和类别等语法特性。例如,类通过`@interface`和`@implementation`定义,对象用`alloc`和`init`创建,方法通过消息传递调用。属性简化变量声明,协议定义可选方法集合,块支持代码块作为参数,类别用于扩展已有类。错误处理常使用NSError对象。要深入了解,建议查阅相关教程和文档。
59 0
|
存储 C语言 C++
C语言面向对象
C语言面向对象
89 1
C语言面向对象
|
存储 程序员 开发工具
面向对象的程序设计C++课堂复盘总结 C语言复习+C++基础语法
Stay Hungry,Stay Foolish. 任何人都能写出机器能看懂的代码,但只有优秀的程序员才能写出人能看懂的代码。 有两种写程序的方式:一种是把代码写得非常复杂,以至于 “看不出明显的错误”;另一种是把代码写得非常简单,以至于 “明显看不出错误”。 “把正确的代码改快速”,要比 “把快速的代码改正确”,容易得太多。 C++ 庞大、复杂是无法改变的事实,所以我们要把这三条格言铭记在心,对它保持一颗 “敬畏” 的心,在学习语言特性的同时,千万不要滥用特性,谦虚谨慎,戒骄戒躁。 -------CSDN Albert Edison
297 0
|
存储 算法 编译器
认知篇----C语言中面向对象的核心思想
认知篇----C语言中面向对象的核心思想
159 0
认知篇----C语言中面向对象的核心思想
|
C语言
软件设计师2007年11月下午试题5(C语言 面向对象)
【说明】       在一个简化的绘图程序中,支持的图形种类有点(point)和圆(circle),在设计过程中采用面向对象思想,认为所有的点和圆都是一种图形(shape),并定义了类型shape_t、point_t和circle_t分别表示基本图形、点和圆,并且点和圆具有基本图形的所有特征。
803 0
|
1月前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
34 3
|
11天前
|
C语言
c语言调用的函数的声明
被调用的函数的声明: 一个函数调用另一个函数需具备的条件: 首先被调用的函数必须是已经存在的函数,即头文件中存在或已经定义过; 如果使用库函数,一般应该在本文件开头用#include命令将调用有关库函数时在所需要用到的信息“包含”到本文件中。.h文件是头文件所用的后缀。 如果使用用户自己定义的函数,而且该函数与使用它的函数在同一个文件中,一般还应该在主调函数中对被调用的函数做声明。 如果被调用的函数定义出现在主调函数之前可以不必声明。 如果已在所有函数定义之前,在函数的外部已做了函数声明,则在各个主调函数中不必多所调用的函数在做声明
27 6