2020-12-23 《数据结构》| 第一章 C及C++基础

侯捷 C++ 课程PPT 代码 笔记 https://github.com/harvestlamb/Cpp_houjie

自定义函数的形式

[存储类型符] [返回值类型符] 函数名([形参说明表])
{
<函数语句体>
}

几点说明

• [存储类型符]指的是函数的作用范围，只有两种形式：static和extern
• static说明的函数称为内部函数，只能作用于其所在的源文件
• extern说明的函数称为外部函数，可被其他源文件中的函数调用
• 缺省情况为extern
• [返回值类型符]指的是函数体语句执行完成后，函数返回值的类型，默认情况为int型（有些编译器不支持默认情况）。
• 通常情况下，自定义的函数在使用之前要先进行函数声明，才能在程序中进行函数调用。函数声明语句的形式：[存储类型符] [返回值类型符] 函数名([形参说明表]);
  如：int abs_sun(int m, int n);

内部函数和外部函数

1. 内部函数

• 函数的存储类型为static型，（内部函数又称为静态函数），它表示在由多个源文件组成的同一个程序中，该函数只能在其所在的文件中使用，在其他文件中不可使用。
  -内部函数的声明形式：static<返回值类型> <函数名>(<参数>);
  例如：static int Statistic ()；
  2. 外部函数
• 若函数的存储类型定义为extern型，则称其为外部函数，它表示该函数能被其他源文件调用。函数的默认存储类型为extern型。
  

递归函数的设计和调用

函数的递归调用

两种递归形式：直接递归调用和间接递归调用。

• 直接递归：函数直接调用自身函数
• 间接递归：函数互相调用对方函数
  
  -可能出现的陷阱：递归调用陷入无限递归状态。
• 递归函数的条件
  递归函数模型在数学上必须具备以下两个条件。
  ①问题的后一部分与原始问题类似。
  ②问题的后一部分是原始问题的简化。
• 难点
  递归函数设计的难点是建立问题的数学模型。

链表

• 基本概念
  ①链表指的是将若干个数据项按一定的规则连接起来的表。
  ②链表中的数据项称为结点。
  ③链表中每一个结点的数据类型都有一个自引用结构
  ④自引用结构就是结构成员中包含一个指针成员，该指针指向与自身同一个类型的结构。

struct node
{ int data;
struct node * nextPtr;
};

-动态分配内存空间的系统函数：
① malloc()和free()函数以及sizeof运算符的配合使用
(注：malloc()和free()函数在头文件stdlib.h或alloc.h)。
②函数原型：void *malloc(unsigned size)
功能：从内存分配一个大小为size个字节的内存空间。若成功，返回新分配内存的首地址；若没有足够的内存分配，则返回NULL。
③通常函数malloc()通常和运算符sizeof一起使用。

int * p;
p=malloc(20*sizeof(int))；／*分配20个整型数所需的内存空间*／

struct student
{ int no;
int score;
struct student *next;
};
struct student *stu;
stu=malloc(sizeof(struct student));
//通过sizeof计算struct student的字节数，分配sizeof（struct student）个字节数的内存空间，stu指向该存储空间的首地址。

• 几点注意：
  ①结构类型占用的内存空间不一定是连续的，因此，应该用sizeof运算符来确定结构类型占用内存空间的大小。
  ②使用mallco()函数时，应对其返回值进行检测是否为NULL，以确保程序的正确。
  ③要及时地使用free()函数释放不再需要的内存空间，避免系统资源过早地用光。
  ④不要引用已经释放的内存空间。
• 链表：通过自引用结构的指针域，将各节点相互连接。
• 关于链表的基本概念
  (1) 链表的第一个结点称头指针或头结点，它指向链表在内存中的首地址，
  (2)其后的结点是通过结点中的链节指针成员访问的。
  (3)链表的最后一个结点称为尾节点。尾节点的指针域通常被设置成NULL。
  (4)链表中的每一个结点是在需要的时候建立的。
  (5)各结点在内存中的存储地址不一定是连续的，由系统自动分配的，即有可能是连续分配内存空间，也有可能是跳跃式的不连续分配内存空间。
• 删除节点方法：修改指针域的值。
  
• 插入节点方法：修改指针域的值。
  
  
  

类

class <类名> {
public:
//成员函数声明；
private:
//数据成员声明；
};

class Day {
public:
void getday ( ); //成员函数声明
void setday ( ); //成员函数声明
private:
int year, month, day;
};

• 几点说明

1. 类定义中的两个关键字:public、private实现了数据封装；
2. public: 表示其下的成员函数可以被本类中的数据成员和成员函数使用；
   (公有的)
3. private: 表示其下的成员函数或数据成员只能被本类中所提供的成员函数使用；
4. 注意：对象不能直接使用private中的成员

• 类的作用域

1. 类中的成员函数可互相直接调用。
2. 类中的数据成员在类中各成员函数间属“公共变量”。
3. 成员函数中的变量若有与类中的数据成员同名同类，则类中的数据成员被隐藏。
   

• 两个要点：

1. 只有类的对象可以访问类的公有成员.
2. 不能直接访问类中private区的成员.

类的静态成员

• 静态数据成员
  做法1：在private区中把数据成员说明为static(静态的)，(可起累加作用)
  作用：属于该类的所有对象引用到该静态数据成员时，使用的是同一个数据成员。
  注意：静态数据成员是必须在类说明之后、main()函数之间赋予初始值。
  赋初值格式：<数据成员类型> <类名>::<数据成员名>=<初值>;
  做法2：在public区中把数据成员说明为static型(静态的)
  作用：可在程序的任何一处直接引用该数据成员而不需通过对象来引用。
  引用格式：类名::静态成员数据名
• 静态成员函数
  做法：在public区中成员函数说明成static型
  作用：程序可以直接引用静态成员，可不需通过对象来引用
  引用格式：类名::静态成员函数名

class count{
private: static int number;
public: static int get( );
};
int count :: number=0;int count :: get( );{ return number;}void main( )
{ int a;
a=count ::get( );
...
}

注意：静态成员函数没有this指针

模板类

模板函数—适合于参数为不同类型的情况，由编译器自动调用
模板类—由程序设计者指明模板类希望被解释成哪种数据类型
由编译器产生指定类的源代码

//模板类的定义格式
template <class Type>
class <类名> {
private: Type *x;
public: <类名>(const int size); //constructor
Type fun1(Type a, Type b);
...
};

//例
#include <iostream.h>
template <class Type>class 
Mytemp { 
private: 
        Type x;
        Type y;
        Type *p;
public: 
         Mytemp (Type *name);
         Type fun1(Type a, Type b);
};

template <class Type>
Mytemp<Type>::Mytemp(Type *name)//构造函数
{ 
  p=name;
}
template <class Type>
Type Mytemp<Type>::fun1(Type a, Type b){ 
    x=a*2;
    y=b*2;
    cout<<"x="<<x<<"\n";
    cout<<"y="<<y<<"\n";
    cout<<"p="<<p<<"\n";
    cout<<"*p="<<*p<<"\n";
    return x+y;
}


void main( )
{ 
   int s=20, a = 18, b = 12, m;
   float t=13.6, x = 9.6, y = 6.6, n;
   Mytemp<int> one (&s);
   Mytemp<float> two (&t);
   m=one.fun1(a, b)
   cout<<"m="<<m<<"\n";n=two.fun1(x, y);
   cout<<"n="<<n<<"\n";
   }

①
②
③
④
①
②
③
④
①
②
③
④