C++第二天学习

回顾：
1.第一个C++程序
头文件
输入输出
名字空间 using namespace std;
扩展名
编译方式 g++

2.名字空间

3.结构、联合、枚举

4.字符串
标准库提供的表示字符串的类型string

5.bool
1 0

6.函数升级
函数重载
相同的作用域，函数名相同，但是参数表不一样

默认参数
1.默认参数一定要靠右
2.避免二义性
3.默认参数要写在声明中
7.动态内存分配
new/delete
1.按类型分配空间
2.在分配空间的同时就可以初始化

delete []p;

-----------------------------------------
1.引用
引用即别名
引用是一个已经定义了的变量的别名。
int a = 10;
int& ra = a;
声明一个引用的格式：
类型& 引用名=已定义的变量;
&:引用声明符，不是取地址
1.一个变量的引用，和它本身是同一个东西，只要改变一个，另一个也随之改变
2.引用最主要的用途是用来作函数参数
swap(a,b); a1 = a,b1 = b;
swap3(a,b); int &a1 = a,int &b1 = b ;
1.节省空间
2.提高效率

3.引用作来返回值

2.类和对象

现实世界： 类
哈士奇
电脑
...
类：是一组具有相同属性和行为的对象的抽象和描述。
抽象：将有关事物的共性归纳、集中的过程。

对象:
万物皆对象。object

在面向对象程序设计中：
类：将多个对象的共性提取出来，定义的一种新的数据类型
是对 对象的属性和行为的抽象和描述。
对象：类 类型的变量
int a ;

类和对象的关系：
类它是抽象的，不占用空间
对象是具体的，占存储空间
类是对象的抽象，对象是类的具体的实例

在面向对象程序设计，总是先声明类，然后再由类生成其对象。

学生：
struct student
{

int num;
string name;
int age;
};

class student
{

int num;
string name;
int age;

void sleep();
void eat();
void study();
};

gg=G
3.结构体与类
1.为了照顾C程序员，所以在C++结构体尽量还是按照C风格来写
2.类比结构体更安全

区别：
结构体在默认情况下，它的成员都是公有的，在任何地方都可以访问
类在默认情况下，它的成员都私有的，在类的外部不能访问。

4.访问限定符
private: 私有的 只有在类的内部可以访问
public: 公有的 在类的内部和外部都可以访问
protected: 受保护的 只在类的内部和其子类可以访问

一般情况下，数据成员私有化，成员函数应该设为公有。

5.类的声明：
class 类名
{
public:
//公有成员（一般为函数）
private:
//私有成员（一般都是数据成员）
protected:
//受保护的成员
};

练习：
写一个类，其功能就是找出一个整型数组元素的最大值。
int array[5] = {1,2,3,4,5};

6.类的组织形式
1.声明一个类 应用放在头文件中
2.实现一个类 用一个.cpp文件来实现类
返回类型 类名::函数名（参数表）
｛｝
3.使用这个类

7.构造函数
构造函数主要用于为对象分配空间进行初始化。
构造函数是一种特殊的成员函数
构造函数的名字与类名要完全相同
构造函数没有返回值
构造函数在创建对象的时候 由系统自动调用，一定会调用，且只调用一次。
当我们在类中没有显式的声明构造函数时，编译器自动会创建一个构造函数，称为默认构造函数。
类名(参数表)
{}
一旦显式的声明了构造函数，系统不会再自动创建了。
构造函数也可以重载，也可以带默认参数

8.析构函数
在对象销毁时，自动调用，处理对象的善后工作。
最常用的用法：就是用来回收内存。
delete xxx
~类名()
{

}
析造函数也是一种特殊的成员函数
析构函数的名字是 ~类名
析构函数没有参数（意味着一个类里只能有一个析构函数）
由系统自动调用
析构函数也没有返回值

9.对象的创建与销毁
1.在栈中创建对象
类名 对象(构造函数参数);
Student s(参数);
2.在堆中创建对象
//int *p = new int;
类名 *对象指针名 = new 类名(构造实参);
student *s = new student;

3.在栈中创建对象数组
//int a[5];
类名 对象数组名[元素个数];

4.在堆中创建对象数组
int *p = new int[元素个数];
类名 *对象指针名 = new 类名[元素个数];

用new 创建的对象 一定要用delete 释放

练习： 实现一个电子时钟类
在构造函数中接收当前系统时间，以秒为单位运行
类的属性：时，分，秒
类的方法：构造函数
运行函数
对时间进行处理的函数
./myClock
17:13:50

int main()
{
MyClock c(...);
c.run();
return 0;
}

time(0);//获取系统时间，返回的是从1970年1月1日0点0分0秒到现在所经过的秒数
localtime();//把time得到的秒转为本地时间

#include<iostream>

using namespace std;

int main()

{

	int a = 10;

	int &ra = a;

	cout << "ra = " << ra << endl;//10

	a = 20;

	cout << "ra = " << ra << endl;//20

	ra = 30;

	cout << "a = " << a << endl;//30

	cout << "&a = "<< &a << endl;//

	cout << "&ra = "<< &ra << endl;//

	return 0;

}

#include<iostream>

using namespace std;

void swap(int a1,int b1)//交换不成功

{

	int temp;

	temp = a1;

	a1 = b1;

	b1 = temp;

}

void swap2(int *a,int *b)//使用指针作为参数，容易出错

{

	int temp;

	temp = *a;

	*a = *b;

	*b = temp;

}

void swap3(int &a1,int &b1)//使用引用作为参数

{

	int temp;

	temp = a1;

	a1 = b1;

	b1 = temp;

}

int main()

{

	int a = 10;

	int b = 20;

//	swap(a,b);

//	swap2(&a,&b);

	swap3(a,b);

	cout << "a = " << a << endl;

	cout << "b = " << b << endl;

	return 0;

}

#include<iostream>

using namespace std;

int& func(int& ra)

{

	ra = ra + 1;

	return ra;

}

int func2(int a)

{

	return a;

}

int main()

{

	int a = 10;

//	int r = func(a);

//	cout << "r = " << r << endl;

	int r2 = func2(a);//r2 = 10

	return 0;

}

#include<iostream>
using namespace std;

class student
{
public:
void sleep()
{
cout << "I am sleeping....." << endl;
}
// void eat();
// void study();
void show()
{
cout << num << endl;
cout << name << endl;
cout << age << endl;
}
private:
int num;
string name;
int age;

};

int main()
{

student s;
/*
s.num = 1001;
s.name = "zhangfei";
s.age = 20;

s.show();
s.sleep();
*/
return 0;
}

#include<iostream>

using namespace std;

class Test

{

	public:

		Test()

		{

			p = new int(100);

			cout << "Test()" << endl;

		}

		void show()

		{

			cout << "p = " << *p << endl;

		}

		~Test()

		{

			delete p;

			cout << "~Test()" << endl;

		}

	private:

		int *p;

};

int main()

{

	Test t;

	t.show();//Test()

	cout << "----------------" <<endl;

	Test *t1 = new Test;//Test()

	delete t1;//~Test()

	cout << "----------------" <<endl;

		//~Test()

	return 0;

}

#include<iostream>
using namespace std;

class array_max
{
public:
/*
array_max()
{
max = 0;
arr = NULL;
arrSize = 0;
cout << "这里是默认构造函数" << endl;
}

array_max(int m)
{
max = m;
cout << "这是带参数的构造函数"<< endl;
}
*/
array_max(int m = 0)
{
max = m;
arr = NULL;
arrSize = 0;
cout << "这里有默认参数的构造函数" << endl;
}
~array_max()
{
cout << "这里是析构函数" << endl;

}

void getArray(int *p,int size)
{
arr = p;
arrSize = size;
}
void init()
{
max = 0;
arr = NULL;
arrSize = 0;
}
int findMax()
{
max = arr[0];
for(int i = 0; i < arrSize; i++)
{
if(arr[i] > max)
{
max = arr[i];
}
}
return max;
}

private:
int max;
int *arr;
int arrSize;
};

int main()
{
int arr[5] = {1,2,3,4,5};
array_max arrMax(100);
array_max a1;
// arrMax.init();//初始化
arrMax.getArray(arr,5);
int r = arrMax.findMax();
cout << r << endl;
return 0;
}