c++学习—类（1） — 成员函数的形式和构造函数
头发要保不住了

怀着对知识的无限渴望，我一口气看了类的众多文字，然后，发现学到的就这么些，哎，菜鸡的我学的太慢了。
类是什么？

类：类是一种用户自定义的复杂数据类型，他是将不同类型的数据和与这些数据相关的操作封装在一起的结合体（有点像c的struct,天真的想法）

类是结构体衍生过来了，为了处理数据隐蔽性问题，暂时我是这么理解的，但是。我觉得类最高级的地方，目前就是装x。
c有struct，但是c++有class。其实差不多，区别就在他们默认数据成员不一样。先说数据成员吧。
数据成员
有三种，一种是public，一种是protected,还有一种是private。

作用：

public 是公共成员，也就是他里面所属的成员是可以被外界随意使用的。

protected是保护成员，具体作用，目前不太懂，讲不清楚，万分抱歉。

private是私有成员，意味着里面所储存的数据类型只有这个结构体（类）可以使用。

一言不可上代码：
#include<bits/stdc++.h>
using namespace std;
class node{
	public:
		int x1,y1;
	private:
		int x2,y2;
}a;

int main()
{
	a.x1 = 1;
	a.y1 = 2;
	cout<<a.x1<<a.y1;
	//下面调用会出错
	a.x2 = 1;
	a.y2 = 2; 
	return 0;
}

出错原因就是x2,y2他是在private里面，外面不能使用它们。

理解了这些，再说struct和class的区别，struct默认里面的成员都是公有的，也就是public，但是class默认是私有的，所以如果要把struct换成class要注意吧类型转换一下，加一个public。（毕竟我们写struct不怎么写public）。

那么问题来了，既然private里面成员不可用，那么有什么意义呢?怎么使用呢？
成员函数
在结构体里写函数，确实可以，但是写的少，因为感觉没必要，但是这是访问私有成员的方法，私有成员可以被写在该类（结构体）的函数调用

请看代码：
#include<bits/stdc++.h>
using namespace std;
class node{
	public:
	void get_x(int a,int b)
	{
		x2 = a;
		y2 = b;
	}
	void print()
	{
		cout<<x2<<y2;
	}
	private:
		int x2,y2;
}a;
//也可以这么写 ,但是要在结构体里先声明。声明应该没问题。 
//void node ::  print()
//{
//	cout<<x2<<y2;
//}
int main()
{
	a.get_x(1,2);
	a.print();
	return 0;
}

简而言之，就是通过处于该类公共区间的函数去调用私有空间的数据。
构造函数
作用：构造函数可以用来对类里面的数据进行初始化。

特点：1.构造函数是每次创造一个类时就会自动调用的，自动运行。

2.构造函数没有返回值，因为是特定的一种方式

3.构造函数的命名一定要和类名一样

具体看代码
#include<bits/stdc++.h>
using namespace std;
class node{
	public:
	node(int a,int b); //声明一个构造函数 此处注意名字要和类名一样，且不需要返回值 
	void print()
	{
		cout<<x2<<y2;
	}
	private:
		int x2,y2;
};

node :: node(int a,int b)	//构造函数书写
{
	x2 = a;
	y2 = b;
 } 
int main()
{
	node a(1,2);	//创造一个类，并初始化。
	a.print();
	return 0;
}

可以看出，构造函数不需要我们调用，是自动执行的。

但是，有的时候，会看到一些大神这么写构造函数。
class node{
	public:
	node(int a,int b):x2(a),y2(b){};
	void print()
	{
		cout<<x2<<y2;
	}
	private:
		int x2,y2;
};



这是成员初始化列表，详情可以自行查询。简而言之，也是一种初始化的方法，为了方便，但是有一些使用细节要注意，比如赋值顺序和命名顺序有关，和变量名先后无关，可以理解成在“：”后面的赋值，是看private里面类型的声明顺序。下面写法就无法完成初始化：
#include<bits/stdc++.h>
using namespace std;
class node{
	public:
	node(int a):y2(a),x2(y2){};
	void print()
	{
		cout<<x2<<y2;
	}
	private:
		int x2,y2;
};

int main()
{
	node a(1);
	a.print();
	return 0;
}

最后会发现x2 = 鬼知道什么数，y2  = 1；也就是程序先将x2初始化，在初始化y2。
拷贝构造函数
拷贝构造函数，顾名思义。就是用于拷贝的构造函数。

格式如下：
类名::类名(const 类名 &对象)
{
	拷贝构造函数函数头。
}

用于拷贝的函数，可以自己写拷贝规则，这个规则你甚至可以写成交换x与y的值。还是比较方便的。下面是一个拷贝构造函数的例子
#include<bits/stdc++.h>
using namespace std;
class node{
	public:
	node(int a,int b);
	node(const node & p)
	{
		x2 = p.x2;
		y2 = p.y2;
	}
	void print()
	{
		cout<<x2<<y2;
	}
	private:
		int x2,y2;
};

node :: node(int a,int b)
{
	x2 = a;
	y2 = b;
 } 
int main()
{
	node a(1,2);
	node b(a);
	a.print();
	cout<<endl;
	b.print();
	return 0;
}

本章就干到这里，在有常用的再补充，欢迎评论补充。其实这里介绍的比较浅显，很多要注意的地方没有说，还有比如构造函数重载、浅拷贝和深拷贝、析构函数等等都没有介绍到。this指针下一节在介绍。想具体学习还请浏览相关书籍。

    只是一个总结,后面附有自己的想法.希望大家多丢砖头啊.有点乱七八糟的感觉。凑合着看下。
    其实我还是没有面向对象的设计思想和觉悟,经常是面向程序,怎么觉得顺手做,就怎么做.刚开始到公司的,其实公司本身在这方面,也是起步,也没有框架.幸好还有一个熟悉WEB开发的人.
    1.第一个Web项目,在一个项目分三层,不过项目很小,就全放到一起了.
    做着做着,对界面有怀疑了,为什么,因为我的界面用于操作表单,我的设计是这样的,在表单列表上面,有打开,新建,审核,删除,查看的功能按钮,但是在显示一个表单的时候,也有 保存并新建,新建,审核,删除的按钮,在具体实现的时候,觉得是比较晕头,直到现在做的系统,才想到了一个简单的,清爽的方法,那就是在表单列表上面,只有打开和新建,把审核,删除,及其它功能全部放到了显示表单的时候才出现.
    2.第二个Web项目,全部是查询,做了一个xml文件格式,用来控制gridview的列头,及绑定的数据列,来显示数据.减少了做界面的时间.加快了开发.
    3.第三个mobile的产品,在技术上面看来,是一种失败,因为把整个程序,做到了500多K之上,关键还是有很多问题,在后期的扩展和维护上面,很费精神,至今还是有一个问题,时间困扰着我,那就是界面,具说在2008年保守计算,这种移动设备只有140多种大小的屏幕.而且在win ce和mobile上面的显示方式有一些不同.
　　 后面我总算是整理了一个新版本,不过现在我已经枪毙它了.因为不想自己写那堆从实体类到数据库,从数据库到实体类的代码,就用了反射,在手持设备上使用了反射.不过那个版本减少了100K的大小.
    4.后面就是新的项目,使用了sliverlight做表单,减少了大量做界面的时间,但是还是进度不快.
　　
    发现,进度不快就是集中在,界面上的操作实体,和数据库表的结构产生的实体是不一致,所有的地方必须做转换,然后又是对已存在的系统作的补充,于是安全起见,只能自动产生SQL,因为有一些字段可以为空,不清楚,以前的系统中的各种功能对这些为空的字段是否做过什么判断.所以又用了反射.不会对主子表,子表中的SQL要不断的反射,还是觉得很可怕的.
     5.中间还做了一个新项目,权限,部门控制那块写的很烂.


　　整理了一下,其实所有的进度,集中在数据转换上面.界面上的数据,至后台,需要转换一次.后台至界面上的数据,需要转换一次,然后从对象转成为正式的SQL又得来一次.然后在界面上的虚拟操作,基本和一次增删改,没啥区别了,最大的区别,只是虚拟的,没有保存到数据库中.

　　


　　为了这个转换问题,从界面上的Model.转换成数据Model.再从数据Model产生SQL,我专门写了源代码产生的模板,每个数据Model里面除了本身的属性外,还加上了一个根据传入的实体Model,产生SqlPart类的方法.

　　
SqlPart类属性string sql,sqlparameter[] params,ColumnsType columntype
ColumnsType IsAutoKey,IsInKey,IsNullEable,NotNull
如Student
public static SqlPart GetSqlPart(Student model);

　　
    再在common空间下面写了三个方法CreateInsertSql,CreateDeleteSql,CreateUpdateSql.


　　界面上将单独写Model来进行操作.它将被封装在界面这块.打算让它独立出来.从后台传来的数据,将通过一个方法转换为一个UIModel.UIModel本身带有增,删,改,得到数据,针对表单操作来说.因为现在用的是Siverlight,它将有一个内存的源.如果在Asp.Net,可能会做一个页面级别的缓存(没想好).这个UIModel,本来也是打算在mobile上面实现的,因为我不太喜欢写这种代码,
txtSheetNo.Text = iteminfo.sheetno??"";

　　暂时想到的就是这些.请多提意见.

垃圾收集算法
(1)标记清除
根据根搜索确定对象是否已死，已死对象标记，然后一起清除。
这个其实不算什么算法，最正常想法应该就是这样。但是，缺点
是效率不高，如果有很多不连续的小对象需要回收，会花好多时间
。另外，造成内存碎片也是问题，分配新的对象和分配大对象不好解决。
(2)标记复制
简单的做法，把内存分成两块，内存永远在其中一块上分配。
垃圾回收时，把存活的对象复制到另一块连续分配，然后把前一块
内存全清除即可。这种方法是浪费一半内存，代价有点大。
PS:以后内存大小如果不是问题，不知道会不会用这种算法?
大多数情况下，对象的存活期应该是朝生夕灭，所以，专门留出
一半的空间来准备备份是没有必要的。
hotspot虚拟机的算法是内存分为一块大的eden空间和两块较小
的survivor空间(注意:只是新生代，不是全部内存，后面会说到新生代)
其中一块survivor用作备份存活对象，eden和survivor可以用来分配内存。
这样浪费的空间就只有一个survivor。
另外一个问题随之而来，并不能保证存活下的对象全能被一个survivor容纳。
不能容纳的对象必须有别的内存来担保，这个工作是由老生代担当的。
从名字也可以看出老生代存放的是存活周期比较老的对象。
(3)标记整理算法
佩服这个算法的创造者┏ (^ω^)=☞
老生代没有额外的担保空间，但是又需要垃圾回收，聪明的人想到了办法。
每次垃圾回收时，把存活的对象向内存的另一侧移动，然后清除回收前的起点到
另一侧占用的边界之间的内存。
(4)分代收集算法
把内存分为新生代和老生代。新生代用的是复制算法，
老生代用的是标记整理算法。作者把分代算法和前面三种算法
并列，感觉不是一个层次的东西。计算机书籍，理解即可。
 
转载于:https://www.cnblogs.com/zwm512327/p/3528950.html

一、类的静态数据成员有什么用?


　　类实现了数据和数据的操作封装在一起，每个类的对象都会分配好内存来保存自己的数据成员，但是往往某个类的众多对象需要一些数据共享，比如定义了Person类，实例化了person1，person2，person3，但是我现在想知道我到底实例化了多少个person对象，怎么办?一个想法是定义一个count数据，这个数据为这些person对象共享，每个person都可以访问该count数据成员，这就是类的静态数据成员的作用：静态成员是解决同一个类的不同对象之间数据和函数共享的问题。


　　二、怎么定义一个静态数据成员


　　用关键字 static 来定义，比如 static int count 。


　　三、实例


　　看如下代码：


PHP 代码:

class Point

{ 

public: 

    Point(int m=0, int n=0 )


    { 

         this->x = m ;


         this->y = n  ;


         this->count ++ ;


    } 

    ~Point() { this->count -- ; }


    int getX() { return this->x ;}


    int getY() { return this->y ;}


    void ShowCount() { cout << "The numbers of count are :" << this->count << endl;}


private: 

    int x ;


    int y ;


    static int count ;     


} 
int Point::count = 0 ; 



　　count 就被定义为 静态成员变量，那么 count 就可以为所有的Point 对象所共享，通过对象名.ShowCount 来访问 count：


PHP 代码:

Point A(4,5) ;

A.ShowCount() ;  //  1 

Point B(A) ;

B.ShowCount()   // 2 



　　count 为 静态成员，每个对象的创建和销毁都会影响到count 。


　　四、静态数据成员需要注意的地方


　　1. 静态数据成员不属于任何一个对象，它只属于类。


　　2. 静态数据成员的初始化要在实例化对象之前，否则你要是用 类名::静态数据成员 来访问 (这个可以在没有实例化对象)输出错误结果。


　　3. 一般静态成员不能在内联函数中访问。


五、 类的静态函数成员


　　在上面的例子中，每个对象都与一个 ShowCount 的拷贝，可以与 类的静态数据成员一样，设为共享方式。这就需要定义为静态函数成员了。


　　相关定义如下：

PHP 代码:

class Point

{ 

public:  
Point( int m , int n ) { x = m ; y = n ; count++ ;}

Point( Point & p) ;


~Point() { count-- ;}


static void ShowCount() { cout << count << endl; }


private: 
int x ; 
int y ; 

static int count ;


}  
int Point::count = 0 ; // 注意初始化的方式 



　　在如下代码中：

PHP 代码:

Point A(4,5) ;

A.ShowCount() ; // 通过对象名引用

Point:: ShowCount() // 通过类名来引用，推荐使用这个方式 



　　需要注意的是，静态成员函数中不可以使用 this 指针，一般是用来访问 静态数据成员的，不做其他用途。(访问非静态成员需要通过参数传递对象名，通过对象名来访问)。