c++课程总结----第一章

老师讲的好好 喜欢喜欢

#include <bits/stdc++.h>//+Ag
using namespace std;
#define qio ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
typedef long long ll;
// cpp 面向对象的语音 
int main()
{
	/*对象 ：特征 行为*/
//	 类  有相同属性和行为 
//	 封装性 继承性 多态性
//	 封装性实现的数据的隐藏 提高数据的安全性

	/*类的定义*/
	class Name{//不能是关键字 通常首字母大写 //默认是private
		public://可以在括号外使用 
			void setxy(int x, int y);
			void display();*函数成员 
		protected://可以类的成员函数及其子类（派生类）
			
		private://只有类中的成员 
			 int X,Y;///*数据成员 
		
	};//虽然写外面但是还是属于类里面 也可以写在类里面 
	void Name::setxy(int x,int y){//指明是类里面的 不然是全局的 
		X=x;
		Y=y;//X指的是类里面的 
	}
	void Name::display(){
		cout << X << " " << Y;
	}
	/* C++类代码组织：提倡分成两个文件:
	一部分是类的说明（.h文件），另一部分是类的实现（.cpp文件）。
	类的说明：
		仅包括类的所有数据成员以及成员函数的函数原型，放在头文件（例如point.h）
	中，便于共享使用。（.h是头文件） 
	类的实现：
		即成员函数实现放在与头文件同名的源文件(例如point.cpp)中，便于修改。有利
	于为一个类的同一界面提供不同的内部实现。
	*/
	//将.h写在外面
	#include "Name"//自定义使用这个"" 类是实现放在.cpp里面
	
	
	/*对象*/
	#include "Name.h"
	#include <iostream>
	//可以将类的实现放在.cpp中 
	using namespace std;
	int main()
	{
		Name p1,p2;
		Name *p3;//和int用途一样 
		//对类成员访问 如下 
		 p1.setxy(1,2);
		 //不能用p1.X=1;因为是私密的 
		 p1.display();
		 p3->display();
		 (*p3).setxy(1,2);
		return 0;
	}
	/*.h文件格式*/
	#include "stdafx.h"//预编译头stdafx.h并不是标准的C++头文件，本质上相当于VS默
	//认的自定义文件，可修改其name，path及内涵等
	#include <string>
	#include <iostream>
	using namespace std;
	class Stu{
		private:
			int nam;
		public:
			void set(int a);	
	};
	/*this指针*/
	//是指向成员函数的 存在this指针（地址） 
	 class Point 
		{
			public:
				void setxy(int x,int y) 
				{ X=x; Y=y; }
				void Point::displayxy( )
				{ cout<<"("<<X<<","<<Y<<")"<<endl; }
			private:
				int X,Y; //坐标
		}
//		实际上
		void setxy(Point*this,int x,int y){
			this->X=x;this->Y=y; 
		} 
//		this地址代表了调用函数对象的地址
		Point p1;
		p1.setxy(1,2);//this表示了p1的地址传到了setxy里面
		
		
		
		
		/*静态对象*///一开始运行就分配空间 到运行结束//作用区域不一样
		
		
/*静态对象的作用域是定义它的函数体或程序文件；其生存期是
整个程序的运行时间。
构造静态对象的次序按它们在程序中出现的先后次序，且在整
个程序运行开始时（即在主函数运行前）只构造一次。
静态对象所占的存储空间被分配在程序的静态区（全局区）中。*/
		static s1;//即静态对象
		//局部对象再动态区中
		
		
		/*构造函数与析构函数*///是类里面的函数 作用是初始化和清理工作 比较特殊的函数
//		构造函数（constructor） 一般与类同名
		class N{
			privat:
				int number;
				int age;
			public:
				N(int a,int b);/*1.必须是public 2.要同名 3.没有返回值 4.可以多个 5.不能显式调用 会被主动调用*/
				void show(); 
		};
		N::N(int a,int b){
			number=a;
			age=b;
		}//有点像初始化
		void N::show(){
			cout << number << age; 
		}
		 int main(){
		 	N a(1,2);*一定要输入 //或者在构造函数里初始化了也可以不用输入 
		 	a.show;
		 }
		//默认构造函数 每个类必须至少有一个构造函数 没有会自动添加
		/*
		类名 () 
		{ } 
		*/
		class N{
			privat:
				int number;
				int age;
			public:
				N();
				N(int a,int b);
				N(int a,int b=1);//具有默认参数值的构造函数
				void show(); 
		};
		N::N(int a,int b){
			number=a;
			age=b;
		}
		N::N()
		{
			number=0;
			age=16
		}//可以重载 
		void N::show(){
			cout << number << age; 
		}
		 int main(){
		 	N a(1,2),b;
		 	a.show;
		 	b.show;
		 }
	//具有默认值注意避免二义性
	/*初始化列表*/ 
	N::N(int a,int b):number(a),age(b)//初始化列表 1.效率高 2.是初始化对象是某些特殊成员的唯一方法，如对象成员 
	{
	} 
	/*拷贝构造函数*///名字也是类的名字 参数是该对象的引用
	class N{
		privat:
			int number;
			int age;
		public:
			N();//构造函数 
			N(student &s);//拷贝构造函数 
			void show(); 
	};
	N::N(int a,int b):number(a),age(b){
		
	}
	N::N(student &s){
		number = s.number;
		age = s.age;
	}
	void show(){
		cout << number << " " << age;
	}
	int main(){
		N a(1,2);
		N b(a);
		a.show();
		b.shaw(); 
	}
	/*拷贝构造函数的三种调用*/
//	函数调用构造形参
	void Fun(Person p) {p.show();}
	Person per1(1001,"Sheldon");
	Fun(per1);
//	函数返回值为对象时
	/*默认构造函数*///成员及拷贝(也叫浅拷贝) 和上面写的一样
	
	
	
	/*析构函数*///执行清理任务  ~类名(){} 
	class N{
		privat:
			int number;
			int age;
		public:
			N();
			N(student &s);
			~N();
			void show(); 
	};
	N::~N(){
		delete[]number;
		delete[]age;
	}//系统自动调用 有默认的 不能重载 先构造的后被析构  
//	浅拷贝有指针时有可能有安全方面的隐患 只复制指针值 
//	用深拷贝
/*
	深拷贝：
*/ 
	//对象数组和堆对象
	/*
		
	*/
//		先调用子对象 先调用了 
		 
		 
//		堆对象	使用运算符new调用构造函数可以动态地创建对象，即堆对象。
	 new clscc YV
//	静态数据成员 同一类的各个对象之间共享数据 给静态成员赋初值 必须在全剧变量 
	class N{
		privat:
			int x;
			int y;
		public:
			N();
			N(int x,int y);
			static int n;
			void show(); 
	};
	int N::n=0;//静态成员的初始化 所有对象共享一个n
//	静态数据成员不属于任何一个对象，而是属于类，被该类的所有对象共享。
//  类的静态数据成员必须进行初始化，且初始化语句要写在程序的全局区域中.
 	N::N(int x,int y){
 		this->x=x;
 		this->y=y;
 		n++;
	 }
	N::N(){
		x=0;
		y=0;
		n++;
	}	 
	int main()
	{
		N p1();
		p1.show;
		cout << p1.n << endl;
		cout << N::n << endl;//调用n
		
	}	 
	/*静态成员函数*/
//	 类的静态成员函数不与任何对象联系，它只能访问类的静态成员。
//   类的普通成员函数既可以访问静态成员，也可以访问普通成员。 
	class N{
		privat:
			int x;
			int y;
			static int n;
		public:
			N();
			N(int x,int y);
			static int getn(){
				return n;
			}
			void show(); 
	};
	int N::n=0;
//	(省略)
	cout << N::getn() << endl;
	
	
	
	
	
	/*友元函数和友元类（共享访问）*/
//	 友元函数本身不是这个类的成员。 友元函数不是本类的成员函数，但在它的函数体中可以通过对象名访问类的私有
//	 和保护成员
	class N{
		privat:
			int x;
			int y;
			static int n;
		public:
			N();
			N(int x,int y);
			static int getn(){
				return n;
			}
			void show(); 
			friend d (N &p1,N &p2)
			d1 (N &p1);
	};
	
	int d (N &p1,N &p2)
	{
		int d;
		d=sqrt((p1.x-p2.y)*(p1.x-p2.y)) //重点是d是友元函数 可以直接调用私有参数
//		 可以和183的vision对比一下 
		return d;
	 } 
	int N::d1(N &P){
		
	}
	int main()
	{
		N p1(1,1);
		N p2(2,2);
		int dis=d(p1,p2);//d就是普通的成员函数 不是类的成员函数 
		int dis1=p1.d1(p2);
	}
	 
	
	
	
	
	
	
	
	return 0; 
}