C++ 02从简单程序引入1

//#define BASIC1_COUT
//#define BASIC1_CIN
//#define BASIC_CLASS1
//#define BASIC_STRING_SORT
//#define BASIC_STRING_SEARCH
//#define BASIC_NEW_DELETE
//#define BASIC_REFERENCE		//引用
//#define TEMPLATE_FUNCTION    //模板函数
#define FUNCTION_OVERLOADING    //函数重载

/************************************
1、对象
【1】对象一般由属性attribute和行为behavior构成，对象之间通过传递消息联系。
【2】C++中，对象由数据和函数组成，数据体现属性，函数体现行为，又称为方法method；调用对象的函数就是向对象传递消息message。
【3】设计复杂的软件系统时，首要的问题就是确定系统由哪些对象组成。

2、封装和信息隐蔽
【1】对象的部分属性和行为封装，对外界隐蔽，既可以降低操作难度，同时有利于数据安全。
【2】设计对象的过程就是在封装，对象之间互相独立，互不干扰，同时对象内部也要考虑到封装。
----
1】私有数据和公用接口：一般指定所有数据私有和外界隔离，通过公用成员函数作为接口实现对数据操作。
2】接口与实现的分离：成员函数对数据成员操作称为实现，但与调用无关的部分都封装不让改变称为私有实现；公用接口和私有实现构成信息隐蔽。
3】信息隐蔽的优点：方便类修改和扩充，只需修改有关部分；
3、抽象abstraction
抽象就是将有关事物的共性归纳、集中的过程，表示同一类事物的本质。类是对象的抽象，而对象时类的特例。

4、继承与重用
两个类基本相同，后者只需在前者基础上增加一些新内容，就是面向对象的继承机制。
软件重用 software reusability，利用现成的类。

5、多态性
继承产生的不同类的对象，对同一个消息会做出不同的响应。

6、内置函数： inline function; 编译时会将所调用的函数代码直接嵌入到主函数中，提高效率。
1]使用方法：函数名的最左端加上inline;
2]使用限制：只将语法简单，规模很小而且很频繁使用的函数声明为内置函数。
3]类体内定义的成员函数如果不包括循环等控制结构，C++系统会自动将它们作为内置函数来处理，隐含指定，这点区别于其他inline内置函数。
类体外定义的成员函数，要通过Inline作声明才能成为内置函数。

7、成员函数存储方式
1]对象的数据存储单元存放的数据各不相同，但调用的函数代码相同；对象的空间大小取决于数据单元，而函数代码存储在对象空间之外。
2]c++的this 用来指向不同对象。

8、引用对象成员
1].称为成员运算符，限定访问的对象成员或函数；还有对象的指针，对象的引用，三种访问对象成员的方法。每个类至少要有一个public函数。

9、类库和调用：
1]类的声明放在头文件，类的定义/实现放在.obj。
只需编译一次行程obj，需要的时候直接用来连接即可。若干类的声明集中在一起，形成类库，包括编译系统的标准类库和自定义类库。
2]类库一般状态C++编译系统的子目录下，程序包含类声明头文件即可调用。
************************************/

//站在用户的角度考虑，输入输出界面要亲切友好。
//函数重载
#ifdef FUNCTION_OVERLOADING


#include <iostream>

using namespace std;

int max(int a, int b, int c);  //同名函数的重载，必须函数参数的个数或类型不同。
int max(int a, int b);		   //重载的同名函数功能需要相同或相近，不同做不相干的功能。

/*
int max(int a, int b, int c);
double max(double a, double b, double c);
*/

int main(int argc, char *argv[])
{
	int a = 8; 
	int b = -23;
	int c = 28;

	cout<<"max(a,b) = "<<max(a, b)<<endl;   //函数名相同，参数个数和函数体不一样。
	cout<<"max(a,b,c) = "<<max(a, b, c)<<endl;

	system("pause");
	return 0;
}

int max(int a, int b)
{
	if (a > b)	
	{
		return a;
	}
	else
	{
		return b;
	}
}

int max(int a, int b, int c)
{
	if (b > a)
	{
		a = b;
	}
	if (c > a)
	{
		a = c;
	}
	return a;
}


#elif defined TEMPLATE_FUNCTION

#include <iostream>

using namespace std;

//适用于函数体相同，参数类型一样而类型不同的情况。
//使用方法：template <typename T> 下面再跟上函数的定义
//返回3个参数中的最大值
template <typename T>
T max(T a, T b, T c)  //模板声明，T为虚拟类型名；函数自适应传入的参数类型
{
	if (b > a)
		a = b;
	if (c > a)
		a = c;
	return a;
}

int main(int argc, char * argv[])
{
	int i1 = 185;
	int i2 = -76;
	int i3 = 456;
	int i =0;

	double d1 = 34.5;
	double d2 = 43.5;
	double d3 = 45.6;
	double d;

	long g1 = 1234;
	long g2 = 321;
	long g3 = 354;
	long g;

	i = max(i1, i2, i3);  //调用模板函数，系统根据参数的类型来取代模板虚拟类型。
	d = max(d1, d2, d3);
	g = max(g1, g2, g3);

	cout<<"i_max = "<<i<<endl;
	cout<<"d_max = "<<d<<endl;
	cout<<"g_max = "<<g<<endl;

	system("pause");
	return 0;
}


#elif defined BASIC_REFERENCE   //引用主要是用来作为函数参数传递数据，变量名作为实参传递。

#include <iostream>
#include <iomanip>        //输出控制符setw的头文件

using namespace std;

void changeValue(int &x, int &y);

int main(int argc, char* argv[])
{
	int a = 10;
	int &b = a;          //声明b是a的引用，所以b和a是同一个变量，a变了b也跟着变，反之亦然，两者共享同一个内存单元。
	int c = 50;			 //声明引用的同时，必须要初始化。

	a = a * a;
	cout<<a<<setw(6)<<b<<endl; //紧接着的输出操作使用的字段宽度设置，包括输出内容本身的宽度
	b = b/5;
	cout<<b<<setw(6)<<a<<endl;
	 if(b!=c)
	 {
		 changeValue(b, c);    //引用作为形参，变量传入以后，形参改变则变量也跟着改变。
		 cout<<"b="<<b<<setw(6)<<"c="<<c<<endl;
	 }

	system("pause");
	return 0;
}

//互换x和y的值 swap  //引用做参数的效果，相当于传递变量的指针，但更直接。
void changeValue(int &x, int &y)
{
	int temp;
	temp = x;
	x = y;
	y = temp;
}


///
#elif defined BASIC_NEW_DELETE
//new和delete是运算符不是函数，执行效率高。
//格式：new 类型 [初值] => float *p=new float(3.14); int *pt = new int [5][4];new分配数组空间时，不能指定初值。
//格式: delete[]指变 ； delete p;   delete []pt;

#include <iostream>
#include <string>

using namespace std;

struct student
{
	string name;
	int num;
	char sex;
};

int main(int argc, char *argv[])
{
	student *p;
	p = new student;  //new运算符开辟一个存放student型数据的空间，返回的指针赋给p
	p->name = "zhang";
	p->num = 130;
	p->sex = 'm';

	cout<<p->name<<endl<<p->num<<endl<<p->sex<<endl;
	delete p;		  //用delete运算符撤销该空间,不需要p=NULL;

	system("pause");
	return 0;
}


//班级里N个学生，把每个学生的姓名和学号输进计算机。通过输进一个学生的姓名查找相关资料。
//查找到此生，输出其姓名和学号；查不到，则输出“查无此人”。
#elif defined BASIC_STRING_SEARCH

#include <iostream>
#include <string>

using namespace std;

int g_studentIndex = 0;
string g_studentName[50];    //string 全局数组不能初始化为0？
string g_studentNum[50];

void InputStudentName();
void SearchStudentName(string findName);

int main(int argc, char *argv[])
{
	string findName;

	cout<<"Please input the number of this class:"<<endl;
	cin>>g_studentIndex;
	InputStudentName();
	cout<<"Please input name you want find:";
	cin>>findName;
	SearchStudentName(findName);

	system("pause");
	return 0;
}

void InputStudentName()
{
	for (int i=0; i<g_studentIndex; i++)
	{	
		cout<<"input name and number of student "<<i+1<<":";
		cin>>g_studentName[i]>>g_studentNum[i];
	}
}

void SearchStudentName(string findName)
{
	bool flag = false;
	for (int i=0; i<g_studentIndex; i++)
	{
		if (findName == g_studentName[i])
		{
			cout<<g_studentName[i]<<"has been found, number is  "<<g_studentNum[i]<<endl;
			flag = true;
			break;
		}
	}

	if (flag == false)
		cout<<"Can't find this name"<<endl;

}



//输入3个字符串，按字符串字母由小到大顺序输出。
//string类型，字符串类型；是在C++标准库中的字符串类，可以用来定义对象。
//赋初值：string str1 = "china";
//直接赋值： str1 = "zhang";  str2=str1; //strcpy
//操作字符串的字符：  string word="then"; word[2]='a';
//字符串常量，以'\0'结尾，但存储到变量中不包括'\0'。
//cin>>str1;
//字符串变量运算：str1=str2+str3; //连接   比较：直接用==,>
//字符串数组： string name[3] ={"i","love","you"};  //长度可变，元素是字符串；每一个字符串元素中只包含字符串本身字符而不包含\0.

#elif defined BASIC_STRING_SORT

#include <iostream>
#include <string>			//string字符串

using namespace std;

int main(int argc, char* argv[])
{
	string string1;
	string string2;
	string string3;
	string temp;

	cin>>string1>>string2>>string3;

	if (string2 > string3)    //字符串交换; 字符串直接赋值
	{
		temp = string2;
		string2 = string3;
		string3 = temp;
	}
	if (string1 < string2)
		cout<<string1<<" "<<string2<<" "<<string3<<endl;
	else if (string1 > string3)
		cout<<string2<<" "<<string3<<" "<<string1<<endl;
	else
		cout<<string2<<" "<<string1<< " "<<string3<<endl;

	return 0;
}



//
#elif defined BASIC_CLASS1

//C++把一组数据和调用数据的函数封装在一起，组成一种称为“类”的数据结构。
//类有两种成员，包括数据成员和成员函数。
class student     //类的声明
{
public:           //公用成员函数
	void setData();
	{
		cin>>num;  //cin对应的是变量，不需要地址.
		cin>>score;
	}
	void display()
	{
		cout<<"num"<<num<<endl;
		cout<<"score"<<socre<<endl;
	}

private:				//私有变量，只有本类的成员函数才能调用，实现数据封装和信息隐蔽的目的。
	int num;
	int score;
};

student stud1,stud2;

int main()
{
	stud1.setData();    //.成员运算符，调用对象的函数。
	stud2.setDate();
	stud1.display();
	stud2.display();
}


//
#elif defined BASIC1_CIN

#include <iostream>
using namespace std;

int main()
{
	int a = 0;
	int b = 0;
	int sum = 0;

	cin>>a>>b;                    //标准库的输入流对象，>>是提取运算符。键盘输入两次数据后各按回车确认。
	sum = a + b;             
	cout<<"a+b="<<sum<<endl;      //endl输出回车; cout 自适应输出格式，不需要printf的格式输出。

	return 0;
}
//流，是指来自设备或传给设备的一个数据流，数据流是由一系列字节组成的，按字节进入流的顺序排列。
//cout<<"表达式1"<<...<<"表达式n";   //系统会自动判别输出数据的类型
//cin>>变量1>>……>>变量n；     //用空格或者回车隔开,系统会根据变量类型从输入流中提取相应长度的字节
//cin 不能输入回车和空格，要用getchar;

#elif defined  BASIC1

//C的头文件要加.h后缀，C++的头文件可加可不加。
#include <iostream>					//iostream代表输入输出流。输入输出流库中的流对象cin和cout.
using namespace std;				//“使用命名空间std”。 //C++标准库中的类和函数是在std中声明的，程序如需要用到标准库(cout)要用此语句做声明。

int main()							//标准C++规定，主函数main必须声明为Int，返回整型数据。
{
	cout <<"This is C++ program";  //cout为对象名，称为输出流对象。<< 插入运算符，将要输出的内容插入到输出流中。

	return 0;					   //向操作系统返回0值。如果程序不能正常执行，则会自动向操作系统返回一个非0值，一般是-1.
}

#endif