类定义：

定义一个学生类Student，使得main()函数能够得到指定的输出结果

main()函数如下：

/* 请在这里填写答案 */
int main()
  {Student stud1(10010,"Wang_li",'f');
   stud1.display();
   Student stud2(10011,"Zhang_fun",'m');
   stud2.display();
   return 0;
}

输入样例：

无

输出样例：
在这里给出相应的输出。例如：

Constructor called.
num:10010
name:Wang_li
sex:f

Constructor called.
num:10011
name:Zhang_fun
sex:m

Destructor called.
Destructor called.

答案如下：

#include <iostream>
#include<cstring>
using namespace std;
class Student
{
	private:
		int NUMBER;
		string NAME;
		char SEX;
	public:
		Student(int number,string name ,char sex)
		{
			cout<<"Constructor called."<<endl;
			NUMBER=number;
            NAME=name;
            SEX=sex;
		}
		void display()
		{
			cout<<"num:"<<NUMBER<<endl;
			cout<<"name:"<<NAME<<endl;
			cout<<"sex:"<<SEX<<endl;
            printf("\n");//没办法了强行换行
        }
		~Student()
		{
            
			cout<<"Destructor called."<<endl;
		}
};
/* 请在这里填写答案 */
// int main()
//   {Student stud1(10010,"Wang_li",'f');
//    stud1.display();
//    Student stud2(10011,"Zhang_fun",'m');
//    stud2.display();
//    return 0;
// }

今天还要继续加油！！！！！

基本类型重载时会自动将小类型提升到int类型

如下的程序

public class Test
{
	public static void main(String args[])
	{
		Test t = new Test();
		t.f1(3); //默认提升为int
		t.f1('a');//调用的还是char
		t.f1((char)3);//进行了显示的转换，所以会调用char的函数
	}
	
	void f1(char x)
	{
		System.out.println("char");
	}
	
	void f1(byte x)
	{
		System.out.println("byte");
	}
	
	void f1(short x)
	{
		System.out.println("short");
	}
	void f1(int x)
	{
		System.out.println("int");
	}
	
	void f1(long x)
	{
		System.out.println("long");
	}
}

为什么不能通过返回值来区别重载

默认构造器

this的两种用法

public class Test
{
	String s = "member var";
	public static void main(String args[])
	{
		Test t = new Test("TT");
	}
	
	Test()
	{
		System.out.println("constructor");
	}
	
	Test(String s)
	{
		//Test(); 构造函数的调用必须用this
		this();
		System.out.println(s);
		System.out.println(this.s); //this的第二种用法，代表当前对象
		// this(); 调用构造函数必须在第一行中调用
	}
	
	Test(int third)
	{
		this();
		this("hello"); //由于构造函数必须在其他构造函数中第一句调用，所以不能同时调用两个构造函数
	}
	
	void func()
	{
		//this(); 不能在非构造函数中调用构造函数
	}
}

Finalize方法

强制系统进行垃圾回收

关于初始化

class Window{
	Window(int marker) {
		System.out.println("window("+marker+")");
	}
}

class House{
	Window w1 = new Window(1);
	House()
	{
		System.out.println("House()");
		w3 = new Window(33);
	}
	Window w2 = new Window(2);
	void f(){ System.out.println("f()");}
	Window w3 = new Window(3); //变量会先于构造函数初始化
}

public class Test{
	public static void  main(String[] args)
	{
		House s = new House();
		s.f();
	}
}

1.类的构成

class  类名 {
public:
  公有数据成员;
  公有成员函数;
protected:
  保护数据成员;
  保护成员函数;
private:
  私有数据成员;
  私有成员函数;
 };

private只能本类的成员函数访问

protected可以由本类或者派生类访问

public是任意函数能访问

private出现在程序的开始时，关键词可以省略。

不能在类中给数据成员赋值，需要在构造函数中赋值。

2.成员函数的声明

在类中给出函数声明：

返回类型  成员函数(参数列表);

在类外给出函数定义：

返回类型  类名∷成员函数名(参数表)
  {
       // 函数体
  }

内联函数：函数体放在类中。

外联函数：函数头放在类中，定义在类外。

内联函数性能优于外联函数，在外联函数前面加上inline可以将外联函数转化为内联函数。

一般较短的定义为内联函数比较合适，较长的定义为一般函数。

3.对象的定义和使用

声明对象

可以在声明类的同时定义，也可以在声明后定义。

class  Coord { 
    public:
        void setCoord(int,int);
        int getx();
        int gety();
    private:
        int  x,y;
    }   op1,op2; 

class  Coord { 
     //…
  }; 
     // …
 main()
 {
   Coord  op1,op2;
     // …
  }

访问对象的方法

对象名.数据成员名

对象名.成员函数名

其实是一种缩写：

对象名.类名::成员名

如果定义指向对象的指针，使用->访问成员

对象赋值

相同类型变量可以互相赋值，赋值方法为逐位拷贝。

如果类中存在指针，可能会出现错误。

4.构造函数与析构函数

构造函数作用

初始化成员变量，

没有返回类型，

可以没有参数

必须和类同名，不需要用户调用。

class 类名
{ public:
	类名（形参表）;		//构造函数的原型
	//类的其它成员
};
类名::类名（形参表）	//构造函数的实现
{
	//函数体
} 

构造函数初始化参数的方式

在函数体内赋值

或者使用初始化列表的方式

类名::构造函数名(参数表):(成员初始化表)
{
    // 构造函数体
}

初始成员列表的形式为：

数据成员名1(初始值1),数据成员名2(初始值2),…… 

拷贝构造函数

使用一个已经存在的对象初始化新对象

如果使用等号赋值，系统自动调用拷贝构造函数。

拷贝构造函数也是构造函数，只有一个参数，是同类对象的引用。

可以对拷贝构造函数进行自定义：

class 类名
{  public :
       类名（形参）；//构造函数
       类名（类名 &对象名）；//拷贝构造函数
           ...
}；
类名:: 类名（类名 &对象名）//拷贝构造函数的实现
{    函数体    }

拷贝构造函数的使用：

Coord p2(p1);    // 用对象p1初始化对象p2, 
Coord p3=p1;    // 用对象p1初始化对象p3, 

缺省拷贝构造函数：如果没有定义拷贝构造函数，C++自动使用逐个成员拷贝的方式。

浅拷贝：默认拷贝函数的方式，逐一拷贝数据成员。如果数据成员出现指针会产生错误。

深拷贝：自定义拷贝，将指针所指的内存进行拷贝

类组合构造函数

类组合指的是类的成员是一个类的对象。

类组合构造函数必须对本类中的基本类型成员数据赋值，也要对对象成员初始化。

类名::类名(对象成员所需的形参，本类成员形参)
       ：对象1(参数)，对象2(参数)，......
{  本类初始化  }

先调用内嵌对象的构造函数，然后调用本类的构造函数。

析构函数

与类名称相同，多一个~，不能被重载，无函数值，没有参数，没有返回值

生命周期结束时，系统自动调用。

调用顺序

构造函数1->构造函数2->构造函数3->结构函数3->解构函数2->解构函数1

向前引用声明

如果需要在类声明之前引用该类，需要向前引用声明。

要求在完整声明其之前不能声明该类的对象。可以声明该类的指针。但是不能使用该类的方法或者成员变量。

class B;  //前向引用声明
class A
{  public:
      void f(B b);
};
class B
{  public:
      void g(A a);
};