C++课堂笔记0711

1.类的声明和定义
C++中类定义类的声明部分一般分为类声明部分和类的实现部分。类的声明部分用来说明
类中的成员（数据成员，数据函数），告诉使用者干什么。
类实现部分用来定义成员函数，该函数用来对数据成员进行操作，告诉使用者怎么干。
类的定义的一般形式 ：
class <类名 >
{
public：
    <成员函数或变量 >；
protected:
     <成员函数或变量 >；
privated:
      <成员函数或变量 >；
}；




学生类：  声明
class student{
public:
int num;
char sex;
protected:
char name[10];
private:
int age;
};


类体定义类的成员：
1）数据成员：它们指定了该类对象的内部表示 ；
2) 成员函数：它们指定该类的操作；


类成员有3种不同的访问权限：
1.public：   既可以被本类中的成员函数访问，也可以被类的作用域内的其他函数访问；
2.private：  只能被该类的成员函数访问，类外的其他函数则不能；
3.protected：只能被该类的成员函数和派生类的成员函数访问。
不指定就默认私有。




类的成员函数通常在类外定义，形式如下：
返回类型 类名：：函数名（形参表）
{
    函数体；
}


例：
void  Cdata::SetData(int y, int m,int d)
{
    year = y;
    month = m;
    day = d;
}




#include <iostream>                    
using namespace std;


class Cdate  
{
 public: //下面定义3个公有成员均为成员函数
    void  SetDate (int y,  int m,  int d); //设置日期，用它使对象（变量）获取数值 
    int   IsLeapYear ( ); // 用来判断是否闰年的函数 
    void  Print ( ); // 用来将年、月、日的具体值输出
 private:
     int  year,  month,  day; //定义3个int 型变量 year 、 month 、day的私有成员
 };
//下面为日期类的实现部分
 void  Cdate :: SetDate( int y, int m, int d ) //设置日期使对象获取数据
 {
    year=y; //私有成员变量year获取数值
    month=m; //私有成员变量month获取数值
    day=d; //私有成员变量day获取数值
 }
 
 
int  Cdate::IsLeapYear( ) //判断闰年的成员函数的实现
{
        return (year %4 ==0&& year %100 != 0) ||( year %400==0);
//如为闰年则返回1
}


void   Cdate :: Print( ) //用来将年月日的具体值输出
{
     cout<<year<<","<<month<<","<<day<<endl;
}






















void main()
{
  int rn; //定义一个整形变量rn，用来接收判断闰年函数的返回值
  Cdate date1; //声明对象
 
  date1.SetDate(2004, 12, 30); //给对象date1的成员函数赋值
  rn = date1.IsLeapYear(); //判断闰年的成员函数返回值赋给rn
  if (rn==1) 
  cout<<"闰年"<<endl;//输出信息
  date1.Print(); //调用对象的成员函数返回具体的年月日值
}




























2. 对象的定义和使用
对象是类的实例，对象属于某个已知的类。在定义对象之前，一定要定义好类。
对象定义格式为：
<类名><对象名表>
例：
Cdata data1，data2, *Pdata,data[3];


对象的成员格式：
<对象名>.<成员名>（<参数表>）




#include <iostream>                    
using namespace std;
//下面为类的声明部分
class Carea 
{
      private:
          int x, y; //声明两个私有变量x和y
      public:
          void set_values (int a,int b); //声明设置矩形长宽值的函数，用来为私有变量赋值
          int area(); //声明计算面积的成员函数
};
//下面为矩形面积类的实现部分
void Carea::set_values (int a, int b)
{ //设置长宽值，使对象获取数据
   x = a; //私有变量x获取数据
   y = b; //私有变量y获取数据
 }
 int Carea::area ()
 { 
     return (x*y); //通过函数值返回面积
 }
 int main ()
 {
    Carea rect1, rect2; //声明两个对象rect1和rect2
    rect1.set_values (3,4); //为对象rect1的成员函数的参数赋值
    rect2.set_values (5,6); //为对象rect2的成员函数的参数赋值
    cout << "rect1 area: " << rect1.area() << endl;
    cout << "rect2 area: " << rect2.area() << endl;
    return 0;
}








2.构造函数
C++中定义了一种特殊的初始化函数，称为构造函数；当对象被调用时，构造函数自动调用；
构造函数名字与类名相同，也没有返回类型和返回值；
对象在生成过程中通常需要初始化变量或分配动态内存，用构造函数。


#include <iostream>              
using namespace std;
class Carea{
   private:
      int width, height;
   public:
      Carea(int,int); //构造函数声明
      int area (); //计算面积的成员函数的声明
};
//以下为构造函数的定义
 Carea::Carea (int a, int b) {
       width = a;
       height = b;
 }
 int Carea::area () { //计算面积的成员函数的实现
      return (width*height); //通过函数值返回面积
 }
 int main () {
       Carea rect1 (3,4); //创建rect1对象并调用构造函数进行初始化
       Carea rect2 (5,6); //创建rect2对象并调用构造函数进行初始化
       cout << "rect1 area: " << rect1.area() << endl;        //输出面积值
       cout << "rect2 area: " << rect2.area() << endl;        //输出面积值
       return 0;
 }  
 
 
 
 
#include <iostream>                  
#include <string>
using namespace std;
class Stud //声明一个类
{
   private: //私有部分
      int num;
      char name[10];
      char  sex;
   public: //公有部分
      Stud(); //构造函数
      void display(); //成员函数
 };
 Stud::Stud() //构造函数定义，函数名与类名相同
 {
     num=10010; //给数据赋初值
     strcpy(name, "suxl");
     sex='F';
 }
 void  Stud::display() //定义成员函数，输出对象的数据
 {
    cout<<"学号: "<<num<<endl;
    cout<<"姓名: "<<name<<endl;
    cout<<"性别: "<<sex<<endl;
 }
 void  main()
 {
    Stud stud1; //定义对象stud1时自动执行构造函数
    stud1.display(); //从对象外面调用display()函数
 }
 
 
 
 3. 析构函数 
 析构函数，是在对象被删除前由系统自动执行它作清理工作。
 
#include <iostream>
using namespace std;
class Carea {
       int * width, * height; //默认为私有变量
public:
    Carea (int,int); //构造函数的声明
   ~Carea (); //析构函数的声明
   int area ( ); //计算面积的成员函数
 };
//以下为构造函数的定义
 Carea::Carea (int a, int b) {
     width =  new int; //定义一个整形指针变量width
     height = new int; //定义一个整形指针变量height
     *width = a; //把参数a的值赋给指针变量width
     *height = b; //把参数b的值赋给指针变量height
 }
    //以下为析构函数的定义
Carea::~Carea () 
{
    delete width; //释放指针变量width占用的内存资源
    delete height; //释放指针变量height占用的内存资源
    cout<<"释放对象占用的内存资源"<<endl; //调用析构函数的信息提示
}
int Carea::area () { //计算面积的成员函数的实现
    return ((*width)*(*height)); //通过函数值返回面积
}
int main () 
{
    Carea  rect1 (3,4), rect2 (5,6);
    cout << "rect1 area: " << rect1.area() << endl;
    cout << "rect2 area: " << rect2.area() << endl;
    return 0;
 }
 
 
 4.析构函数调用顺序




#include <iostream>
using namespace std;   //是指标准库中输入输出流的头文件， cout就定义在这个头文件里


class Test           //定义类
{
   private:   //私有变量
       int num;
   public:
       Test(int a)   //定义构造函数
       {
          num = a;
          cout<<"第"<<num<<"个Test对象的构造函数被调用"<<endl;
       }
       ~Test() //定义析构函数
       {
          cout<<"第"<<num<<"个Test对象的析构函数被调用"<<endl;  
       }
 };
 
 
 
 int  main()
 {
       cout<<"进入main()函数"<<endl;
       Test t[4] = {0,1,2,3}; //定义4个对象，分别以0、1、2、3赋给构造函数的形参a
       cout<<"main()函数在运行中"<<endl;
       cout<<"退出main()函数"<<endl;
       
       return 0;
}


















5. 有元函数
C++中，为了使类的私有成员函数和保护成员能够被其他类或其他成员函数访问，引入友元概念。
5.1 友元成员
一个类的成员函数时另一个类的友元函数，则称这个成员函数为友元成员。通过友元成员函数，不仅可以
访问自己所在类的对象中私有和公有成员，还可以访问friend声明语句所在的类的对象中的私有和公有成员。
可以使两个类相互访问，从而共同完成某个任务。
class A
{
    friend void B::BmemberFun();
    publicL
}




#ifndef X_H
#define X_H
#include<iostream>    //是指标准库中输入输出流的头文件， cout就定义在这个头文件里
#include<string>
using namespace std;    //字符串头文件
class Y;              //为向前引用
class X              //定义类X
{
      int x;
      char *strx;        //定义私有成员
  public:
      X(int a,char *str)   //定义构造函数
      {
      x=a;            
      strx=new char[strlen(str)+1]; //分配空间
      strcpy(strx,str);   //调用字符串拷贝函数
    }
    void show(Y &ob);   //声明公有成员函数
};
#endif






#ifndef Y_H
#define Y_H
#include"X.h"
class Y            //定义类Y
{
     int y;       
     char *stry;
   public:
     Y(int b,char *str) //定义构造函数
     {
      y=b;
      stry=new char[strlen(str)+1];
      strcpy(stry,str);
         }
     friend void X::show(Y &ob)               //声明友元成员
     {
    cout << "the string of X is: " << strx << endl;
    cout << "the string of Y is: " << ob.stry << endl;
} };
#endif!




#include"X.h"
#include"Y.h"
void main()
 {
     X a(10, "stringx");        //创建类X的对象
     Y b(10, "stringy");        //创建类Y的对象
     a.show(b);
 }
 
 
 

7.8
1. 构造函数
和类名相同；
没有返回值；
没有显示调用；
在创建对象的时候自动执行；




2。析构函数
~ 类名()




3。this
指向当前对象；可以执行当前对象的所有内容。
this 只能用在类的内部；
this就是一个指针；


4. static
static修饰成员变量，相当于一个全局变量；
static成员必须在类的外部初始化；