虚拟函数使得对象用同一个名字,调用不同函数.
这种多态实现了某种概念的抽象.
用回调也可以达到类似的效果,某种意义上,用回调更灵活.
由于C++的类回调函数的强类型导致用起来不够灵活方便,
这里的回调函数可以用Delegate代替.


其实用回调是典型的使用聚合而不使用继承的思路.
最典型的例子就是Thread类,
通常的做法是写一个非虚拟的Run,调用虚拟的Excute.
用到Thread的地方,继承Thread实现Excute即可.
而用回调的方式,只需设置回调即可,不用新建一个类来继承.
尤其当用到的Thread较多时,避免了类的数目的膨胀.


针对接口编程,经常声明一个接口类,
一方拥有这个接口,使用这个接口,另一方从这个接口继承,实现接口.
如果采用Delegate的方法,有时可以省去单独的接口类.







虚拟函数的问题在于其同时实现了接口继承和实现继承.
而回调函数可以看作接口继承,因此更灵活.

虚拟方法表由编译器自动处理,回调函数由人工管理.



但是,虚拟函数基于类,同一个类的对象共享一个虚拟方法表,
而回调函数却是基于对象的,每个对象都有一个回调函数指针.
能否让对象共享同一个回调函数指针?
类可以共享静态变量,但类和子类也共享该静态变量.
(单例模式不能继承就面临的这个问题,用模板实现编译时多态).
那么除非根据函数名结合类名查表,调用不同函数.


如果语言支持与子类独立的类级共享变量,
也就是说在父类声明一个类级变量,子类中也有一个同名的类级变量.这两个变量同名但独立.
就像虚拟方法表一样有一个虚拟变量表就好了.
这样就可以实现前面的基于类的回调函数.


语言不直接支持,我们只有diy了

//ClassVariable代表类共享变量.
//ClassVariable中主要存放的是类级回调函数,或者说Deletegate.

struct  ClassVariable

{


};


//每个类都声明一个同名的静态成员变量ClassVar;

class TObject
{
  static ClassVariable* ClassVar;
 virtual  ClassVariable* GetClassVariable(){return ClassVar};
//或者通过一个全局的hash表,由类名得到相应的ClassVar

};

每个类从父类继承并扩展相应的ClassVariable结构.

那么如何实现多态呢?
在一个非虚拟函数里,调用ClassVar所指向的一个运行时设定的Deletegate.



使用ClassVar前

借鉴QT中的RTTI的相关思路.

提供一个函数,进行类型转换,将通用的ClassVariable,
转换为与类相关的特定类型的指针.



某种意义上RTTI信息就是类的共享的数据.
可以研究下C++的Rtti,以及类库的Rtti的实现原理.







如果C++直接支持delegate,虚拟变量表,消息机制就好了





如果每一个类对应的rtti构成一个包含vmt成员的MetaClass,并且用户可以自定义继承,扩充之就好了.









(Click here for a personal note from Marshall Cline.) 








C++ FAQ /

Section 31 / FAQ 31.2 
Section 31: 

31.1
What is value and/or reference semantics, and which is best in C++?
31.2
What is "virtual data," and how-can / why-would I use it in C++?
31.3
What's the difference between
virtual data and dynamic data?
31.4
Should I normally use pointers to freestore allocated objects
 for my data members, or should I use "composition"?
31.5
What are relative costs of the 3 performance hits associated
 with allocating member objects from the freestore?
31.6
Are "inline
virtual" member functions ever actually "inlined"?
31.7
Sounds like I should never use reference semantics, right?
31.8
Does the poor performance of reference semantics mean I should pass-by-value?

 E-mail the author

[ Subject index | About the author | ©
 ]

Revised Jul 4, 2012





[31.2] What is "virtual data," and how-can / why-would I use it in C++?


virtual data allows a derived class to change the exact class of a baseclass's member object.
virtual data isn't strictly "supported" by C++,however it can be simulated in C++. It ain't pretty, but it works.
To simulate virtual data in C++, the base class must have a pointer to themember object, and the derived class must provide a
new object to bepointed to by the base class's pointer. The base class would also have oneor more normal constructors that provide their own referent (again via
new),and the base class's destructor would delete the referent.
For example, class Stack might have an Array member object (using apointer), and derived
class StretchableStack might override the baseclass member data from
Array to StretchableArray. For this to work,StretchableArray would have to inherit from
Array, so Stack would have anArray*. Stack's normal constructors would initialize this
Array* with anew Array, but Stack would also have a (possibly
protected)constructor that would accept an Array* from a derived class.StretchableStack's constructor would provide a
new StretchableArrayto this special constructor.
Pros:
Easier implementation of StretchableStack(most of the code is inherited)
Users can pass a StretchableStack as a kind-of Stack
Cons:
Adds an extra layer of indirection to access the Array
Adds some extra freestore allocation overhead(both new and delete)
Adds some extra dynamic binding overhead(reason given in next FAQ)
In other words, we succeeded at making our job easier as theimplementer of
StretchableStack, but all our users 
payfor it. Unfortunately the extra overhead was imposed on both users ofStretchableStack
and on users of Stack.
Please read the rest of this section. (You will not get a balancedperspective without the others.)

文章目录
视图
简介
创建视图
修改视图
查看视图和删除视图
更新视图
视图与表的对比
变量
分类
系统变量
自定义变量

视图
简介
-- 视图
/*
含义：虚拟表
MySQL5.1版本出现的新特性，是通过表动态生成的数据，只保存了SQL逻辑，不保存查询数据
应用场景：
1、多个地方用到同样的查询结果；
2、该查询结果使用的SQL语句较为复杂；
*/
# 查询学生中姓张的学生姓名和专业
# 以前我们的做法
USE studb;
SELECT name, majorname
FROM stu_info s
INNER JOIN major m
ON s.majorid = m.id
WHERE s.name LIKE '张%';

# 视图的做法,首先创建一张视图,保存SQL逻辑
CREATE VIEW my_view
AS
SELECT name, majorname
FROM stu_info
INNER JOIN major m ON stu_info.majorid = m.id;
# 使用刚刚创建的视图
SELECT * FROM my_view
WHERE name LIKE '张%';

创建视图
-- 1、创建视图
/*
CREATE VIEW 视图名
AS
查询语句
*/
# 查询姓名中包含a字符的员工名、部门名、工种信息
USE myemployees;
CREATE VIEW my_view
AS
SELECT last_name, department_name, job_title
FROM employees e
INNER JOIN departments d ON e.department_id = d.department_id
INNER JOIN jobs j ON e.job_id = j.job_id;

SELECT * FROM my_view
WHERE last_name LIKE '%a%';


# 查询各部门的平均工资级别
CREATE VIEW my_view1
AS
SELECT department_id, avg(salary) AS avgsalary
FROM employees
GROUP BY department_id;

SELECT my_view1.*, job_grades.grade_level
FROM my_view1
LEFT JOIN job_grades
ON my_view1.avgsalary BETWEEN job_grades.lowest_sal AND job_grades.highest_sal
ORDER BY my_view1.department_id;


# 查询平均工资最低的部门信息
SELECT d.*, my_view1.avgsalary
FROM my_view1
INNER JOIN departments d ON my_view1.department_id = d.department_id
ORDER BY my_view1.avgsalary
LIMIT 1;
# 或者
CREATE VIEW my_view2
AS
SELECT my_view1.*
FROM my_view1
ORDER BY my_view1.avgsalary
LIMIT 1;
SELECT my_view2.avgsalary, d.*
FROM my_view2
INNER JOIN departments d ON my_view2.department_id = d.department_id;

注意：MySQL中视图不支持封装子查询查出来的数据。
视图一旦创建，系统会在视图对应的数据库文件夹下，创建一个对应的结构文件:frm文件。
视图的好处：
1、SQL语句的重用；
2、简化复杂的SQL操作，不必知道它的查询细节；
3、保护数据，提高安全性。
修改视图
-- 2、修改视图
/*
方式一：和创建类似
CREATE OR REPLACE VIEW 视图名
AS
查询语句
*/
# my_view2视图存储的是部门平均工资最低的部门编号和平均最低工资,现在修改为存储工种平均工资
CREATE OR REPLACE VIEW my_view2
AS
SELECT avg(salary), job_id
FROM employees e
GROUP BY e.job_id;
/*
方式二：和修改表类似
ALTER VIEW 视图名
AS
查询语句
*/
ALTER VIEW my_view2
AS
SELECT my_view1.*
FROM my_view1
ORDER BY my_view1.avgsalary
LIMIT 1;

查看视图和删除视图
-- 3、查看视图
/*
DESC 视图名;
*/
DESC my_view2;
SHOW CREATE VIEW my_view2;

-- 4、删除视图
/*
DROP VIEW 视图名,视图名,...;
*/
DROP VIEW my_view;

更新视图
-- 5、更新视图(针对数据的更新,DML语句)
CREATE OR REPLACE VIEW my_view3
AS
SELECT last_name, email
FROM employees;

# 插入数据
INSERT INTO my_view3  VALUES ('张飞', 'zhangfei@qq.com');
SELECT count(*) FROM my_view3;
-- 108,插入成功
SELECT count(*) FROM employees;
-- 108,更新视图数据,使得原始表中的数据也发生了改变

# 修改数据
UPDATE my_view3 SET last_name = '刘备' WHERE last_name = '张飞';

# 删除数据
DELETE FROM my_view3 WHERE last_name = '刘备';
SELECT count(*) FROM my_view3;
-- 107
SELECT count(*) FROM employees;
-- 107

-- 所以在更新视图时，会影响原始表中的数据，这种现象是不好的，所以我们需要给视图增加权限，只读
-- 其实我们上面的视图，是最简单的，实际中的视图会有许多复杂的SQL语句，是不具备可更新性的，所以更新视图很少很少用

/*
以下类型的视图是不能更新的:
• 包含以下关键字的sql语句：分组函数、distinct、group by、having、union或者union all
• 常量视图
• Select中包含子查询
• join
• from一个不能更新的视图
• where子句的子查询引用了from子句中的表
*/

视图与表的对比
-- 6、视图与表的对比
--          创建语法        是否实际占用物理空间          使用
-- 视图   CREATE VIEW         否（只有逻辑占用空间）     增删改查，一般不能增删改
-- 表    CREATE TABLE        是                       增删改查

变量
分类
-- 变量
/*
分类：
1、系统变量
    全局变量
    会话变量（客户端的一次连接）
2、自定义变量
    用户变量
    局部变量
*/
-- 一、系统变量
/*
变量由系统提供，不是用户定义，属于服务器层面
*/
-- 1、查看所有的系统变量
SHOW GLOBAL VARIABLES;
# 查看所有全局变量
SHOW SESSION VARIABLES;
# 查看所有会话变量，SESSION关键字可以省略
-- 2、查看满足条件的部分系统变量
SHOW GLOBAL VARIABLES LIKE '%char%';
SHOW SESSION VARIABLES LIKE '%char%';
-- 3、查看指定的某个系统变量
SELECT @@CHARACTER_SET_SERVER;
-- 4、为某个具体的系统变量赋值
/*SET GLOBAL AUTOCOMMIT = 0;*/


系统变量
-- 二、全局变量
SHOW GLOBAL VARIABLES;
# 查看指定的全局变量
SELECT @@AUTOCOMMIT;
# 1
SELECT @@TX_ISOLATION;
# 查看事务的隔离级别
# REPEATABLE-READ
/*
作用域：可以跨连接（会话），不能跨重启
*/

-- 三、会话变量
SHOW SESSION VARIABLES;
# SESSION 可以省略
SHOW VARIABLES LIKE '%char%';
SELECT @@CHARACTER_SET_SERVER;
/*
作用域：只针对当前连接（会话）有效
*/

自定义变量
-- 四、自定义变量
/*
说明：变量是用户自定义的，不是系统的;
使用步骤：
1、声明
2、赋值
3、使用
*/
-- 1、用户变量
/*
针对当前会话/连接有效，
应用在任何地方，begin...end里面/begin...end外面，（存储过程）
*/
# 声明并初始化
  SET @用户变量名=值;（=有判断的意思）或者
  SET @用户变量名:=值; 或者
  SELECT @用户变量名:=值;
# 赋值
# 方式一（通过SET或者SELECT)
	SET @用户变量名=值; 或
 	SET @用户变量名:=值; 或
	SELECT @用户变量名:=值
# 方式二（通过SELECT...INTO）
	SELECT 字段 INTO 变量名 FROM 表名 （这个结果必须是一个值）***
# 使用（查看、比较、运算）
  SELECT @用户变量名;
  
-- 声明并初始化
SET @name:='john';
SELECT @name;
# john
SET @name:=200;
SELECT @name;
# 200
SET @count:=1;
-- 赋值
SELECT COUNT(*) INTO @count FROM beauty;
-- 查看
SELECT @count;
# 12

-- 2、局部变量
/*
作用域：在局部有效，定义它的begin...end中有效，并且是begin...end的第一句
*/
# 声明
DECLARE 变量名 类型;
DECLARE 变量名 类型 DEFAULT 值;
# 赋值
# 方式一：通过SET或者SELECT
	SET 局部变量名=值;
	SET 局部变量名:=值;
	SELECT @局部变量名:=值;
# 方式二：通过SELECT...INTO
	SELECT 字段 INTO 局部变量名 FROM 表名;
# 使用
SELECT 局部变量名; 

# 案例：声明两个变量赋初始值，并求和打印
-- 1、用户变量
SET @a=10;
SET @b=20;
SET @sum = @a + @b;
SELECT @sum;

MFC虚拟列表使用详解
在列表中显示大量数据时，比InsertItem操作更快。

mfc基本对话框工程建立后，添加list_control控件，并设置属性（必须）
我这里使用样式为


为列表控件添加变量（m_listcontrol）
参考各种帖子的做法，添加一个继承CObject的类，命名为CLabelItem。

在CLabelItem类中重载 操作符=，和构造函数。


CLabelItem(const CLabelItem& ci);
const CLabelItem& operator=(const CLabelItem& stringSrc);

为list_control添加消息（LVN_GETDISPINFO）处理函数

消息处理函数如
void Cobj_show_extra_windowsDlg::OnLvnGetdispinfoListSelf(NMHDR *pNMHDR, LRESULT *pResult)
{
	//NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
	// TODO: 在此添加控件通知处理程序代码
	LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR; 
	LV_ITEM* pItem= &(pDispInfo)->item; 
	/*m_arLabels_self 在头文件中定义  CArray <CLabelItem,CLabelItem> m_arLabels_self*/
	CLabelItem rLabel = m_arLabels_self.ElementAt(pItem->iItem); 
	if (pItem->mask & LVIF_TEXT) //valid text buffer?
	{  
		CString msg;
		switch (pItem->iSubItem)
		{
		case 0:	//第0列			
			break;
		case 1:	//第1列	
			lstrcpy(pItem->pszText, rLabel.obj_csOrigin);
			break;
		default:
			break;
		}

	}
}

添加数据
	UpdateData(TRUE);
	// TODO: 在此添加控件通知处理程序代码
	char * pszCols[]={"xx", "xx", "xx", "xx", "xx", "xx", "xx", "xx", "xx"};
	CString strText;
	int i;
	LVCOLUMN	Col;
	Col.mask= LVCF_TEXT;
	for(i=0; i<9; i++)
	{
		strText= CString(pszCols[i]);
		Col.pszText=strText.GetBuffer(strText.GetLength()+1);
		Col.cchTextMax=strText.GetLength()+1;
		myFirstDlg->m_listcontrol.SetColumn(i, &Col);
		strText.ReleaseBuffer();
	}
	 
	m_arLabels_self.RemoveAll();
	m_arLabels_self.SetSize(1000, 2);

	CLabelItem Label;
	for(i=0; i<90; i++)
	{
		Label.obj_iNumber		= 10;
		....	//CLabelItem 成员变量赋值
		m_arLabels_self.SetAtGrow(i, Label);
	}
	m_listcontrol_self.SetItemCount(i);
	m_listcontrol_self.Invalidate();//通知列表数据已经准备好，可以更新显示

（cpu：i7-7700k，ram：16g）

测试时，当列表只有两列时，填充500行大约需要4ms。当列数增加9列，填充500行，时间到达30-40ms。明显上升。

用apache做项目时，是经常需要在httpd-vhost.conf文件中配置虚拟主机，用于单独的项目，每新开一个项目就需要重新加一个配置，着实麻烦，apache2其实是支持在配置虚拟主机的时候，设置变量的 ，这样可以通过域名来指向相应的文件夹，因此每个项目的域名只要遵循一定的规则，服务器基本不用配置。
比如我本地会有school   weixin    test这三个项目 按照传统做法是需要配置三个虚拟主机，但是按照以下的配置，一条配置就够了：
 <VirtualHost *:80>
    ServerAlias  local.*.cn
     VirtualDocumentRoot /home/qiang/www/%2
 </VirtualHost>



这样  本地的三个项目只需要按照   local.school.cn    local.weixin.cn    local.test.cn这样的域名来访问 服务器就自动找到对应的项目路径 在/home/qiang/xxx下了（当然域名要配host)
注意：使用这个VirtualDocumentRoot配置需要apache加载了vhost_alias这个模块
动态安装这个模块的方法是 进入之前下载的编译安装的apache文件夹目录里边 即     xxxxxx/httpd-2.2.xxxx/modules/mappers/  目录下 


进入这个目录后 会找到一个mod_vhost_alias.c
然后执行以下命令
/usr/local/apache/bin/apxs -i -a -c ./mod_vhost_alias.c


待命令执行完毕 重启服务器 配置就生效了