#VALUE!（函数返回的错误值），经常使用excel表格的同学并不陌生。因函数使用时参数等导致出现#VALUE!问题，对于表格表姐，这本不是什么太大的困难，但要是遇到一个强迫症表哥，数据表格中满眼#VALUE!，这压力有多大是可以想象的到的。还有一点，没有几个领导会对有#VALUE!存在的报告有好感，所以，还是找去掉#VALUE!的解决方案吧。
 赠送一个嵌套函数，你不用知道它内部是如何运行，只要复制、粘贴、向下填充就可以。
 一张图学会去掉#VALUE!的嵌套函数
 举个例子，你正在汇总某个关键词微博的评论次数，一部分微博有评论，还有一部分微博是没有评论的，现在需要原微博中，提取评论次数进行汇总。如下图所示。
 
 
 
 
 
 
 
 
 
从“收藏 评论(7)”中提取评论后括弧中的数字7，其他行雷同。关于字符提取函数大多采用MID，RIGHT，LEFT这三个。由于括弧中数字不确定位数，可能是空值，也可能是几百几千，因此最合适的方法就是采用MID函数、FIND函数和LEN函数进行嵌套，用FIND函数判断“评论”的位置，用LEN函数判断原字符串长度。
 原公式=MID(单元格,FIND("评论",单元格) 3,(LEN(单元格))-(FIND("评论",单元格) 3))
 结果很不爽，遇到了#VALUE!。因为0次评论的，没有括弧和数字，函数参数出现错误。现在需要去掉#VALUE!
 赠送一个神嵌套函数：=IF(ISERROR(原公式),"",VALUE(原公式))
 VALUE函数用于 将表示数字的文本字符串转换成可运算的数字，因为上一个原公司提取后得到其实是字符而不是数字格式，因子需要将字符格式的数字转化为数字格式，怎么用，具体看上一篇博客。
 ISERROR用于判断原公式是不是返回了一个错误值。IF函数就不解释了，百度。
 “一张图学excel函数”在下方给出了处理的结果，一目了然。如果读者朋友想亲自尝试一下，可以点击这里下载源数据自行实践。

C++函数参数的缺省值
 
有一些参数的值在每次函数调用时都相同，书写这样的语句会使人厌烦。C++语言采用参数的缺省值使书写变得简洁（在编译时，缺省值由编译器自动插入）。
 
    参数缺省值的使用规则：
 
【规则8-3-1】参数缺省值只能出现在函数的声明中，而不能出现在定义体中。
例如：
 
    void Foo(int x=0, int y=0); // 正确，缺省值出现在函数的声明中
 
 
 
    void Foo(int x=0, int y=0)      // 错误，缺省值出现在函数的定义体中
 
    {
 
…
 
    }
 
为什么会这样？我想是有两个原因：一是函数的实现（定义）本来就与参数是否有缺省值无关，所以没有必要让缺省值出现在函数的定义体中。二是参数的缺省值可能会改动，显然修改函数的声明比修改函数的定义要方便。
 
 
 
【规则8-3-2】如果函数有多个参数，参数只能从后向前挨个儿缺省，否则将导致函数调用语句怪模怪样。
正确的示例如下：
 
void Foo(int x, int y=0, int z=0);
 
错误的示例如下：
 
void Foo(int x=0, int y, int z=0); 
 
 
 
要注意，使用参数的缺省值并没有赋予函数新的功能，仅仅是使书写变得简洁一些。它可能会提高函数的易用性，但是也可能会降低函数的可理解性。所以我们只能适当地使用参数的缺省值，要防止使用不当产生负面效果。示例8-3-2中，不合理地使用参数的缺省值将导致重载函数output产生二义性。
 
 
 
 
#include <iostream.h>
 
void output( int x);
 
void output( int x, float y=0.0);
 
 
 
 
void output( int x)
 
{
 
    cout << " output int " << x << endl ;
 
}
 
 
 
 
void output( int x, float y)
 
{
 
    cout << " output int " << x << " and float " << y << endl ;
 
}
 
 
 
 
void main(void)
 
{
 
    int x=1;
 
    float y=0.5;
 
//  output(x);          // error! ambiguous call
 
    output(x,y);        // output int 1 and float 0.5
 
}
 
 
 
示例8-3-2  参数的缺省值将导致重载函数产生二义性

 
 
 
c++ 构造函数详解
构造函数是干什么的
构造函数的分类
拷贝构造函数
浅拷贝与深拷贝
 

 
c++ 构造函数详解
 
构造函数是干什么的
 
该类对象被创建的时候，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作，故：构造函数的作用：初始化对象的数据成员
 
构造函数的分类
 
无参构造函数
带默认值的构造函数
有参（无默认值）的构造函数
复制构造函数（拷贝构造函数） 
  
一种特殊的构造函数，当对象之间复制时会自动调用拷贝构造函数
若类中没有显示定义拷贝构造函数，则系统会自动生成默认拷贝构造函数
 
 
	#include <iostream>
	using namespace std;
	
	class Coordinate
	{
	public:
		// 无参构造函数
		// 如果创建一个类你没有写任何构造函数，则系统自动生成默认的构造函数，函数为空，什么都不干
		// 如果自己显示定义了一个构造函数，则不会调用系统的构造函数
		Coordinate()
		{
			c_x = 0;
			c_y = 0;
		}     
	
		// 一般构造函数
		Coordinate(double x, double y):c_x(x), c_y(y){}   //列表初始化
		// 一般构造函数可以有多个，创建对象时根据传入的参数不同调用不同的构造函数
	
		Coordinate(const Coordinate& c)
		{
			// 复制对象c中的数据成员
			c_x = c.c_x;
			c_y = c.c_y;
		}
	
		// 等号运算符重载
		Coordinate& operator= (const Coordinate& rhs)
		{
			// 首先检测等号右边的是否就是等号左边的对象本身，如果是，直接返回即可
			if(this == &rhs)
				return* this;
			// 复制等号右边的成员到左边的对象中
			this->c_x = rhs.c_x;
			this->c_y = rhs.c_y;
			return* this;
		}
	
		double get_x()
		{
			return c_x;
		}
	
		double get_y()
		{
			return c_y;
		}
	
	private:
		double c_x;
		double c_y;
	};
	
	int main()
	{
		// 调用无参构造函数，c1 = 0，c2 = 0
		Coordinate c1, c2;
		// 调用一般构造函数，调用显示定义构造函数
		Coordinate c3(1.0, 2.0);
		c1 = c3;    //将c3的值赋值给c1，调用"="重载
		Coordinate c5(c2);
		Coordinate c4 = c2;    // 调用浅拷贝函数，参数为c2
		cout<<"c1 = "<<"("<<c1.get_x()<<", "<<c1.get_y()<<")"<<endl
			<<"c2 = "<<"("<<c2.get_x()<<", "<<c2.get_y()<<")"<<endl
			<<"c3 = "<<"("<<c3.get_x()<<", "<<c3.get_y()<<")"<<endl
			<<"c4 = "<<"("<<c4.get_x()<<", "<<c4.get_y()<<")"<<endl
			<<"c5 = "<<"("<<c5.get_x()<<", "<<c5.get_y()<<")"<<endl;
		return 0;
	}
 
	c1 = (1, 2)
	c2 = (0, 0)
	c3 = (1, 2)
	c4 = (0, 0)
	c5 = (0, 0)
	请按任意键继续. . .
 
拷贝构造函数
 
拷贝构造函数是一种特殊的构造函数，具有单个形参，该形参（常用const修饰）是对该类型的引用。当定义一个新对象并用同一类型的对象都它进行初始化时，将显示使用拷贝构造函数，当该类型的对象传递给函数返回该类型的对象时，将隐式调用拷贝构造函数
当类中有一个数据成员是指针时，或者有成员表示在构造函数中分配的其他资源，必须显示定义拷贝构造函数
构造函数的使用情况 
  
一个对象以值传递的方式传入函数体
一个对象以值传递的方式从函数体返回
一个对象需要通过另一个对象进行初始化
 
 
	#include <iostream>
	using namespace std;
	
	class Test
	{
	public:
		// 构造函数
		Test(int a):t_a(a){
		cout<<"creat: "<<t_a<<endl;
		}
	
		// 拷贝构造函数
		Test(const Test& T)
		{
			t_a = T.t_a;
			cout<<"copy"<<endl;
		}
	
		// 析构函数
		~Test()
		{
			cout<<"delete: "<<t_a<<endl;
		}
	
		// 显示函数
		void show()
		{
			cout<<t_a<<endl; 
		}
	
	private:
		int t_a;
	};
	
	// 全局函数，传入的是对象
	void fun(Test C)
	{
		cout<<"test"<<endl;
	}
	
	int main()
	{
		Test t(1);
		// 函数中传入对象
		fun(t);
		return 0;
	}
 
	creat: 1
	copy
	test
	delete: 1
	delete: 1
	请按任意键继续. . .
 
浅拷贝与深拷贝
 
浅拷贝 
  
所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。也就是增加了一个指针，指向原来已经存在的内存。 正常情况下，“浅拷贝”已经能很好的工作，但是一旦对象存在动态成员，浅拷贝就会出问题。让我们考虑下面一段代码：
 
 
	#include <iostream>
	#include <assert.h>    
	using namespace std;
	
	class Test
	{
	public:
		Test(){
			p = new int(10);
		}
	
		~Test(){
			assert(p != NULL);     // assert()作用是如果他的条件返回错误，则终止程序执行 
			delete p;
		}
	private:
		int x;
		int y;
		int* p;
	};
	
	int main()
	{
		Test t1;
		Test t2(t1);    // 调用默认拷贝构造函数
		return 0;
	}
 
上述程序崩溃。在使用t1复制t2时，进行的是浅拷贝，只是将成员的值进行赋值。此时，t1.p = t2.p, 即两个指针指向了堆里的同一个空间。这样，析构函数会被调用两次，这就是错误出现的原因。此问题的解决方法是“深拷贝”。
 
深拷贝 
  
深拷贝就是对于对象中的动态成员，并不只是简单的赋值，而是重新分配空间，即资源重新分配。上述代码处理如下：
 
 
	#include <iostream>
	#include <assert.h>    
	using namespace std;
	
	class Test
	{
	public:
		Test(){
			x = 0;
			y = 0;
			p = new int(10);
		}
	
		Test(const Test& t)
		{
			x = t.x;
			y = t.y;
			p = new int(10);
			*p = *(t.p);
		}
	
		~Test(){
			assert(p != NULL);     // assert()作用是如果他的条件返回错误，则终止程序执行 
			delete p;
		}
	
		int get_x(){return x;}
		int get_y(){return y;}
	private:
		int x;
		int y;
		int* p;
	};
	
	int main()
	{
		Test t1;
		Test t2(t1);    // 调用默认拷贝构造函数
		cout<<"("<<t1.get_x()<<", "<<t1.get_y()<<")"<<endl
			<<"("<<t2.get_x()<<", "<<t2.get_y()<<")"<<endl;
		return 0;
	}
 
(0, 0)
(0, 0)
请按任意键继续. . .
 
 
 
此时t1与t2的p各自指向一段内存空间，但他们指向的内容相同，这就是“深拷贝”。
 

分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow

也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！


                 
 
调用 MS SQL 标量值函数，应该在函数前面加上 "dbo."，否则会报 “不是可以识别的 内置函数名称”错误。例如
 
 
 
    DECLARE @WhichDB TINYINT;
    SELECT @WhichDB = dbo.user_GetWhichDB(1);--看看是哪个数据库的
 
 
 
另外，标量值函数就相当于一个变量，而不是一个表，所以这样写是错误的：
 
    SELECT * FROM dbo.user_GetWhichDB(1);
 
应该这样写：
 
    SELECT dbo.user_GetWhichDB(1);
 
加上别名：
 
    SELECT dbo.user_GetWhichDB(1) AS FieldName;
 
 
 
=================================================
 
--标量值函数
 
ALTER FUNCTION [dbo].[user_GetWhichDB]
(
    @UserId INT = 0
)
RETURNS TINYINT
WITH EXECUTE AS CALLER
AS
BEGIN
    DECLARE @WhichDB TINYINT;
    SET @WhichDB = 1;
    IF @UserId >= 115098
        SET @WhichDB = 2;
    
    RETURN (@WhichDB);
END
            



给我老师的人工智能教程打call！http://blog.csdn.net/jiangjunshow