c++-----------类的学习总结(以代码形式总结，记录)

/***********   screen.h    *****************/
#ifndef _SCREEN_DATA_
#define _SCREEN_DATA_

#include<iostream>
#include <string>
#include <vector>


/*   总结一下：
             类的构造中，还没学到析构函数的作用，应该是销毁作用，我猜的
			 在定义类时，注意，一定要给类中的数据成员初始化，负责定义对象时编译会出错，
			 也要加上default(),利用合成默认构造函数
			 注意定义类中数据成员时，要注意先后顺序，不然赋初值时是根据定义的先后顺序赋得，
			 有时利用前面得成员，则需要先初始化
			 注意给其他类中包括此类的函数或者是成员变量时，需要声明好访问权限，以及定义那个函数时的顺序
			 还有静态成员的规则和好处
                                                     */

 //explicit构造函数是用来防止隐式转换的，这里就不介绍了


class  Screen;
class Window_mgr;

using namespace std;


/*
           如果只给clear提供访问权限那么也只是公共部分成员
	         我这种理解是错的，只要是这个文件里，
	         所有的函数体内都可以访问Screen类的公有成员  **理解错误，必须在Screen定义之后，才能用它，
       如果要使得Window_mgr类中只有clear函数有访问Screen类的所有成员(包括私有)，
	     就得在Screen类之前声明这个函数，否则不能访问
		 * 注意，不能在类的外部单独声明类中得成员函数

                             */

class Window_mgr
{
public:
	void clear(Screen &s);    //注意只给clear访问Screen权限其定义的顺序
	Window_mgr() = default;



private :                                         /*很重要*/
	//vector <Screen> vct{ Screen(24,80,' ') };   //此时还没有定义Screen，所以无法给其初始化，编译器会报错



};


class  Screen
{
public:
	typedef string::size_type pos;
	Screen()=default;                             //contents的初始化过程是连续ht*wd个c字符
	//每一次定义一个对象，则记录一次，++_data_num(静态成员变量)
	//Screen(pos ht, pos wd, char c) { height = ht; width = wd; ++_data_num; };
	//注意这几个构造函数的初始化,第一个加上去就是错误的，不知道为啥
	//      导致在后面的返回*this处有错误，不知道为啥
	Screen(pos ht, pos wd, char c) :height(ht), width(wd) ,contents(ht*wd, c){  ++_data_num; };
	Screen(pos ht, pos wd) :height(ht), width(wd), contents(ht*wd, ' ') {  ++_data_num; };

	char get() const { return contents[cursor]; };
	inline char get(pos ht, pos wd) const;      //显示内联
	Screen &move(pos r, pos c);      //能在之后被设为内联，因为没有定义函数体
	Screen &set(char);
	//重载
	Screen &set(pos, pos, char);
	
	friend void Window_mgr::clear(Screen &s);   //只有clear有访问权限
	//friend class Window_mgr;

	Screen &display(ostream &os)
	{
		do_display(os); return *this;   //隐式地从指向非常量的指针转换成指向常量的指针
	}

	Screen display(ostream &os) const
	{
		do_display(os); return *this;
	}

	static int &data_num() { return _data_num; }



	~Screen() {};

private:
	void do_display(ostream &os) const { os << contents; }
	pos cursor = 0;
	pos height = 0, width = 0;
	string contents;
	static   int _data_num;
	static   const int _DATA_num = 0;   //静态成员是const,则可以初始化
};

inline Screen &Screen::move(pos r, pos c)    //如果有引用的话，得把&放在前面
{
	pos row = r*width;
	cursor = row + c;
	return *this;
}

char Screen::get(pos ht, pos wd) const
{
	pos row= ht * width;
	return contents[row+wd];
}

inline Screen &Screen::set(char c)
{
	contents[cursor] = c;
	return *this;
}
inline Screen &Screen::set(pos r, pos col, char ch)
{
	contents[r*width+col] = ch;
	return *this;
}




inline void Window_mgr::clear(Screen &s)
{
	
	s.contents = ' ';

}



#endif


/***********   Nodefalut.h    *****************/


#include<iostream>
#include <string>
#include <vector>

using namespace std;
class Nodefault
{
public:
	Nodefault(int i) { val = i; };
	
	int val;
	void print();

};

void Nodefault::print()
{
	//vector<Nodefault> vi(10);  //此是不合法的，没有默认初始化
	

};


/*******        main.cpp     ***********/

#include<iostream>
#include <string>
#include <vector>
#include <iterator>
#include "screen.h"
#include "Nodefalut.h"

using namespace std;

/*       静态成员变量应该在类的外部进行初始化，
            最好是在头文件的外面，在使用它的cpp前面初始化，此时不需要加上static
            尽量不要在类的内部初始化，不过要求是字面常量类型的constexpr                            
			比如：static constexpr int data_num=0;	  
			还有一种可以在类的内部初始化静态成员，就是此静态成员是const
										                               */
int Screen::_data_num = 0;   //静态成员变量的初始化


//template <typename T>
int main()
{
	Screen ta(1, 1, 'c');
	Screen ta1(1, 1, 'c');
	Screen ta2(1, 1, 'c');
	Screen ta3(1, 1, 'c');
	Screen ta5(1, 1, 'c');
	/*   类的静态成员存在于任何对象之外，对象中不包含任何于静态数据成员有关的数据
	   所有该类对象都共享这个静态成员，在类中定义时，就独自给了它内存，与对象无关；
	    如果静态成员变量或者函数是public，则不需要使用对象调用静态成员，
		而是直接  class::静态成员  当然也可以用对象来访问它，此时注意（这里对象中的数据成员必须被初始化）
	          */
	cout << Screen::data_num()<<endl; //这样我就实现了数据录入的自动记载记录
	//输出得到data_num=5；

	ta5.data_num() = 6;
	cout << Screen::data_num();
	//Nodefault df;   //因为没有构造默认函数，所以定义时就会出错
	
	/*void Nodefault::print()    //不能在这里定义类的成员函数，必须在一个文件中
	{
		vector<Nodefault> vi(10);
		vi.front();

	};*/


	Screen myScreen(5, 3);
	const Screen ytu(5, 3);
	//myScreen.set('#').display(cout);
	//ytu.display(cout);
	//cout << endl;
	Window_mgr g;
	g.clear(myScreen);
	//myScreen.display(cout);


	//return 0;
	system("pause");
}

怎么学会在逆境中做出最大的输出是最重要的，而不是去寻找同样的感受，去寻求理解，这简直是浪费时间！

学会在环境中做好最好的自己，最好的状态，最好的输出是需要我去做的；你只能尽最大的可能去输出，

先做出自己的改变，才能影响环境！

周末整理好自己这学期要学的课，要买的书，要看的视频，要达到的目标，阶段性目标；

要时刻保持与外界的联系，才知道差距；需要时不时的鞭策自己；

领域这个事，先等一等，可以时刻先关注数据挖掘方向；

因为你有一点统计的底子；但是都需要学的扎实，并且实战能力要强；

关注kaggle这些东西；