分块算法模板

⑴ c++的模板定义

找本C++的书看看，上面讲的都比较详细，而且还有例子。

C++模板概述

只有使用C++语言的少数用户才努力尝试去理解模板的基本原理。然而那些希望去探索更多高级用法的人往往发现自己需要努力去理解模板是如何被语言所支持的，因为缺乏明确的说明。一个很大的问题在于一些工具只实现了C++标准的一个子集。本文将指出它们共同的缺陷并深入剖析如何使用C++模板快速产生可重用和高效的代码。
模板功能应用的典型是通过一系列模板类形成的完整类库，特别是STL和ATL。标准C++库(STL)提供了很多可重用和灵活的类及算法，而ATL则是使用C++进行COM编程的事实标准。要掌握这些及其它的模板库，理解模板是如何工作的这一基础是非常重要的。

函数模板

int main()
{
0 cout<<add(2,3)<<endl;
1 cout<<add(2.1,3)<<endl;
2 cout<<add(2,3.2)<<endl;
3 cout<<add(2.2,3.3)<<endl;
4 cout<<add("hello eone ","world")<<endl;
return 0;
}

也可以通过宏定义#define add(a,b) ((a)+(b))来实现,但是指针(字符串)不能直接相加.对于2,3,4需要进行模板特化.
通过重载函数，我们能够完成多种不同数据类型的相同操作。要实现两个double数值的加法和两个整数类型的加法，我们可以使用一个重载函数：

int add(const int x, const int y)
{
return x + y;
}

double add(const double x, const double y)
{
return x + y;
}

这时，编译器将根据它们的参数正确地解决这一问题。

// 调用int add(const int, const int);
const int z1 = add(3, 2);
// 调用double add(const double, const double);
const double z2 = add(3.0, 2.0);
如果我们需要处理其它类型，我们就不得不提供其他函数重载。对每个不同的数据类型实现一个函数重载，它们都遵循相同的模式，每当我们需要调用针对某一数据类型的函数时，原则上编译器为我们生成相应的代码。而一个模板函数则以如下方式实现：

template<class T>
const T add(const T &t1, const T &t2)
{
return t1 + t2;
}

从概念上来说，编译器通过模板关键字(后面跟随着模板由一或多个模板参数构成的参数列表)来识别模板。当为某一具体类型调用add时，编译器将根据模板定义并用给定的类型替换出现在模板中的参数。在这个例子中，模板参数列表由一个独立的类型模板参数T构成。使用一个模板函数替代函数重载，编译器可以自动为所需的新类型生成代码
我们可以对任何拥有+操作符定义的类型使用add模板。假设一个自定义的String类提供了字符串连接并知道如何将自身写入到std::ostream。因为String与该模板函数兼容，因此我们可以调用它来实现字符串相加：

// 示例字符串
const string strBook("book");
const string strWorm("worm");
// 显示 "bookworm".
cout << add(strBook, strWorm) << endl;
Seeing that we intended to add two String values, the compiler will generate the appropriate add function on our behalf, which would look something like:
const String add(const String &t1, const String &t2)
{
return t1 + t2;
}

显式实例化

调用模板函数时，编译器将先把正确的类型实例化模板。虽然标准允许显式模板实例化，然而并非所有厂商都能够正确地实例它。例如，Visual C++ 6.0 会潜在地调用错误的函数：:
template<class T>
int getSize(void) {
return sizeof(T);
}
// 输出4，应该为8
cout << "double: " << getSize<double>() << endl;
// 输出4，正确
cout << "int: " << getSize<int>() << endl;
跨平台代码设计者不希望依赖于显式模板函数实例化，除非有更好的编译器能够对它提供有效的支持

⑵ c++排序算法相关问题

排序算法是一种基本并且常用的算法。由于实际工作中处理的数量巨大，所以排序算法对算法本身的速度要求很高。
而一般我们所谓的算法的性能主要是指算法的复杂度，一般用O方法来表示。在后面我将给出详细的说明。
对于排序的算法我想先做一点简单的介绍，也是给这篇文章理一个提纲。
我将按照算法的复杂度，从简单到难来分析算法。
第一部分是简单排序算法，后面你将看到他们的共同点是算法复杂度为O(N*N)（因为没有使用word,所以无法打出上标和下标）。
第二部分是高级排序算法，复杂度为O(Log2(N))。这里我们只介绍一种算法。另外还有几种算法因为涉及树与堆的概念，所以这里不于讨论。
第三部分类似动脑筋。这里的两种算法并不是最好的（甚至有最慢的），但是算法本身比较奇特，值得参考（编程的角度）。同时也可以让我们从另外的角度来认识这个问题。
第四部分是我送给大家的一个餐后的甜点——一个基于模板的通用快速排序。由于是模板函数可以对任何数据类型排序（抱歉，里面使用了一些论坛专家的呢称）。

现在，让我们开始吧：

一、简单排序算法
由于程序比较简单，所以没有加什么注释。所有的程序都给出了完整的运行代码，并在我的VC环境
下运行通过。因为没有涉及MFC和WINDOWS的内容，所以在BORLAND C++的平台上应该也不会有什么
问题的。在代码的后面给出了运行过程示意，希望对理解有帮助。
1.冒泡法：
这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡：
#include <iostream.h>
void BubbleSort(int* pData,int Count)
{
int iTemp;
for(int i=1;i<Count;i++)
{
for(int j=Count-1;j>=i;j--)
{
if(pData[j]<pData[j-1])
{
iTemp = pData[j-1];
pData[j-1] = pData[j];
pData[j] = iTemp;
}
}
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
BubbleSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
倒序(最糟情况)
第一轮：10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交换3次)
第二轮：7,10,9,8->7,10,8,9->7,8,10,9(交换2次)
第一轮：7,8,10,9->7,8,9,10(交换1次)
循环次数：6次
交换次数：6次
其他：
第一轮：8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交换2次)
第二轮：7,8,10,9->7,8,10,9->7,8,10,9(交换0次)
第一轮：7,8,10,9->7,8,9,10(交换1次)
循环次数：6次
交换次数：3次
上面我们给出了程序段，现在我们分析它：这里，影响我们算法性能的主要部分是循环和交换，
显然，次数越多，性能就越差。从上面的程序我们可以看出循环的次数是固定的，为1+2+...+n-1。
写成公式就是1/2*(n-1)*n。
现在注意，我们给出O方法的定义：
若存在一常量K和起点n0，使当n>=n0时，有f(n)<=K*g(n),则f(n) = O(g(n))。（呵呵，不要说没
学好数学呀，对于编程数学是非常重要的！！！）
现在我们来看1/2*(n-1)*n，当K=1/2，n0=1，g(n)=n*n时，1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n)
=O(g(n))=O(n*n)。所以我们程序循环的复杂度为O(n*n)。
再看交换。从程序后面所跟的表可以看到，两种情况的循环相同，交换不同。其实交换本身同数据源的有序程度有极大的关系，当数据处于倒序的情况时，交换次数同循环一样（每次循环判断都会交换），复杂度为O(n*n)。当数据为正序，将不会有交换。复杂度为O(0)。乱序时处于中间状态。正是由于这样的原因，我们通常都是通过循环次数来对比算法。

2.交换法：
交换法的程序最清晰简单，每次用当前的元素一一的同其后的元素比较并交换。
#include <iostream.h>
void ExchangeSort(int* pData,int Count)
{
int iTemp;
for(int i=0;i<Count-1;i++)
{
for(int j=i+1;j<Count;j++)
{
if(pData[j]<pData[i])
{
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
}
}
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
ExchangeSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
倒序(最糟情况)
第一轮：10,9,8,7->9,10,8,7->8,10,9,7->7,10,9,8(交换3次)
第二轮：7,10,9,8->7,9,10,8->7,8,10,9(交换2次)
第一轮：7,8,10,9->7,8,9,10(交换1次)
循环次数：6次
交换次数：6次
其他：
第一轮：8,10,7,9->8,10,7,9->7,10,8,9->7,10,8,9(交换1次)
第二轮：7,10,8,9->7,8,10,9->7,8,10,9(交换1次)
第一轮：7,8,10,9->7,8,9,10(交换1次)
循环次数：6次
交换次数：3次
从运行的表格来看，交换几乎和冒泡一样糟。事实确实如此。循环次数和冒泡一样也是1/2*(n-1)*n，所以算法的复杂度仍然是O(n*n)。由于我们无法给出所有的情况，所以只能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍差）。
3.选择法：
现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下）这种方法类似我们人为的排序习惯：从数据中选择最小的同第一个值交换，在从省下的部分中选择最小的与第二个交换，这样往复下去。
#include <iostream.h>
void SelectSort(int* pData,int Count)
{
int iTemp;
int iPos;
for(int i=0;i<Count-1;i++)
{
iTemp = pData[i];
iPos = i;
for(int j=i+1;j<Count;j++)
{
if(pData[j]<iTemp)
{
iTemp = pData[j];
iPos = j;
}
}
pData[iPos] = pData[i];
pData[i] = iTemp;
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
SelectSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
倒序(最糟情况)
第一轮：10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交换1次)
第二轮：7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交换1次)
第一轮：7,8,9,10->(iTemp=9)7,8,9,10(交换0次)
循环次数：6次
交换次数：2次
其他：
第一轮：8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交换1次)
第二轮：7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交换1次)
第一轮：7,8,10,9->(iTemp=9)7,8,9,10(交换1次)
循环次数：6次
交换次数：3次
遗憾的是算法需要的循环次数依然是1/2*(n-1)*n。所以算法复杂度为O(n*n)。
我们来看他的交换。由于每次外层循环只产生一次交换（只有一个最小值）。所以f(n)<=n
所以我们有f(n)=O(n)。所以，在数据较乱的时候，可以减少一定的交换次数。

4.插入法：
插入法较为复杂，它的基本工作原理是抽出牌，在前面的牌中寻找相应的位置插入，然后继续下一张
#include <iostream.h>
void InsertSort(int* pData,int Count)
{
int iTemp;
int iPos;
for(int i=1;i<Count;i++)
{
iTemp = pData[i];
iPos = i-1;
while((iPos>=0) && (iTemp<pData[iPos]))
{
pData[iPos+1] = pData[iPos];
iPos--;
}
pData[iPos+1] = iTemp;
}
}

void main()
{
int data[] = {10,9,8,7,6,5,4};
InsertSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
倒序(最糟情况)
第一轮：10,9,8,7->9,10,8,7(交换1次)(循环1次)
第二轮：9,10,8,7->8,9,10,7(交换1次)(循环2次)
第一轮：8,9,10,7->7,8,9,10(交换1次)(循环3次)
循环次数：6次
交换次数：3次
其他：
第一轮：8,10,7,9->8,10,7,9(交换0次)(循环1次)
第二轮：8,10,7,9->7,8,10,9(交换1次)(循环2次)
第一轮：7,8,10,9->7,8,9,10(交换1次)(循环1次)
循环次数：4次
交换次数：2次
上面结尾的行为分析事实上造成了一种假象，让我们认为这种算法是简单算法中最好的，其实不是，
因为其循环次数虽然并不固定，我们仍可以使用O方法。从上面的结果可以看出，循环的次数f(n)<=
1/2*n*(n-1)<=1/2*n*n。所以其复杂度仍为O(n*n)（这里说明一下，其实如果不是为了展示这些简单
排序的不同，交换次数仍然可以这样推导）。现在看交换，从外观上看，交换次数是O(n)（推导类似
选择法），但我们每次要进行与内层循环相同次数的‘=’操作。正常的一次交换我们需要三次‘=’
而这里显然多了一些，所以我们浪费了时间。
最终，我个人认为，在简单排序算法中，选择法是最好的。

二、高级排序算法：
高级排序算法中我们将只介绍这一种，同时也是目前我所知道（我看过的资料中）的最快的。
它的工作看起来仍然象一个二叉树。首先我们选择一个中间值middle程序中我们使用数组中间值，然后
把比它小的放在左边，大的放在右边（具体的实现是从两边找，找到一对后交换）。然后对两边分别使
用这个过程（最容易的方法——递归）。
1.快速排序：
#include <iostream.h>
void run(int* pData,int left,int right)
{
int i,j;
int middle,iTemp;
i = left;
j = right;
middle = pData[(left+right)/2]; //求中间值
do{
while((pData[i]<middle) && (i<right))//从左扫描大于中值的数
i++;
while((pData[j]>middle) && (j>left))//从右扫描大于中值的数
j--;
if(i<=j)//找到了一对值
{
//交换
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
}while(i<=j);//如果两边扫描的下标交错，就停止（完成一次）
//当左边部分有值(left<j)，递归左半边
if(left<j)
run(pData,left,j);
//当右边部分有值(right>i)，递归右半边
if(right>i)
run(pData,i,right);
}
void QuickSort(int* pData,int Count)
{
run(pData,0,Count-1);
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
QuickSort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的情况
1.数组的大小是2的幂，这样分下去始终可以被2整除。假设为2的k次方，即k=log2(n)。
2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。
第一层递归，循环n次，第二层循环2*(n/2)......
所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n
所以算法复杂度为O(log2(n)*n)
其他的情况只会比这种情况差，最差的情况是每次选择到的middle都是最小值或最大值，那么他将变
成交换法（由于使用了递归，情况更糟）。但是你认为这种情况发生的几率有多大？？呵呵，你完全
不必担心这个问题。实践证明，大多数的情况，快速排序总是最好的。
如果你担心这个问题，你可以使用堆排序，这是一种稳定的O(log2(n)*n)算法，但是通常情况下速度要慢于快速排序（因为要重组堆）。
三、其他排序
1.双向冒泡：
通常的冒泡是单向的，而这里是双向的，也就是说还要进行反向的工作。
代码看起来复杂，仔细理一下就明白了，是一个来回震荡的方式。
写这段代码的作者认为这样可以在冒泡的基础上减少一些交换（我不这么认为，也许我错了）。
反正我认为这是一段有趣的代码，值得一看。
#include <iostream.h>
void Bubble2Sort(int* pData,int Count)
{
int iTemp;
int left = 1;
int right =Count -1;
int t;
do
{
//正向的部分
for(int i=right;i>=left;i--)
{
if(pData[i]<pData[i-1])
{
iTemp = pData[i];
pData[i] = pData[i-1];
pData[i-1] = iTemp;
t = i;
}
}
left = t+1;
//反向的部分
for(i=left;i<right+1;i++)
{
if(pData[i]<pData[i-1])
{
iTemp = pData[i];
pData[i] = pData[i-1];
pData[i-1] = iTemp;
t = i;
}
}
right = t-1;
}while(left<=right);
}
void main()
{
int data[] = {10,9,8,7,6,5,4};
Bubble2Sort(data,7);
for (int i=0;i<7;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
2.SHELL排序
这个排序非常复杂，看了程序就知道了。
首先需要一个递减的步长，这里我们使用的是9、5、3、1（最后的步长必须是1）。
工作原理是首先对相隔9-1个元素的所有内容排序，然后再使用同样的方法对相隔5-1个元素的排序
以次类推。
#include <iostream.h>
void ShellSort(int* pData,int Count)
{
int step[4];
step[0] = 9;
step[1] = 5;
step[2] = 3;
step[3] = 1;
int iTemp;
int k,s,w;
for(int i=0;i<4;i++)
{
k = step[i];
s = -k;
for(int j=k;j<Count;j++)
{
iTemp = pData[j];
w = j-k;//求上step个元素的下标
if(s ==0)
{
s = -k;
s++;
pData[s] = iTemp;
}
while((iTemp<pData[w]) && (w>=0) && (w<=Count))
{
pData[w+k] = pData[w];
w = w-k;
}
pData[w+k] = iTemp;
}
}
}
void main()
{
int data[] = {10,9,8,7,6,5,4,3,2,1,-10,-1};
ShellSort(data,12);
for (int i=0;i<12;i++)
cout<<data[i]<<" ";
cout<<"\n";
}
呵呵，程序看起来有些头疼。不过也不是很难，把s==0的块去掉就轻松多了，这里是避免使用0
步长造成程序异常而写的代码。这个代码我认为很值得一看。
这个算法的得名是因为其发明者的名字D.L.SHELL。依照参考资料上的说法：“由于复杂的数学原因
避免使用2的幂次步长，它能降低算法效率。”另外算法的复杂度为n的1.2次幂。同样因为非常复杂并
“超出本书讨论范围”的原因（我也不知道过程），我们只有结果了。

四、基于模板的通用排序：
这个程序我想就没有分析的必要了，大家看一下就可以了。不明白可以在论坛上问。
MyData.h文件
///////////////////////////////////////////////////////
class CMyData
{
public:
CMyData(int Index,char* strData);
CMyData();
virtual ~CMyData();
int m_iIndex;
int GetDataSize(){ return m_iDataSize; };
const char* GetData(){ return m_strDatamember; };
//这里重载了操作符：
CMyData& operator =(CMyData &SrcData);
bool operator <(CMyData& data );
bool operator >(CMyData& data );
private:
char* m_strDatamember;
int m_iDataSize;
};
////////////////////////////////////////////////////////
MyData.cpp文件
////////////////////////////////////////////////////////
CMyData::CMyData():
m_iIndex(0),
m_iDataSize(0),
m_strDatamember(NULL)
{
}
CMyData::~CMyData()
{
if(m_strDatamember != NULL)
delete[] m_strDatamember;
m_strDatamember = NULL;
}
CMyData::CMyData(int Index,char* strData):
m_iIndex(Index),
m_iDataSize(0),
m_strDatamember(NULL)
{
m_iDataSize = strlen(strData);
m_strDatamember = new char[m_iDataSize+1];
strcpy(m_strDatamember,strData);
}
CMyData& CMyData::operator =(CMyData &SrcData)
{
m_iIndex = SrcData.m_iIndex;
m_iDataSize = SrcData.GetDataSize();
m_strDatamember = new char[m_iDataSize+1];
strcpy(m_strDatamember,SrcData.GetData());
return *this;
}
bool CMyData::operator <(CMyData& data )
{
return m_iIndex<data.m_iIndex;
}
bool CMyData::operator >(CMyData& data )
{
return m_iIndex>data.m_iIndex;
}
///////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//主程序部分
#include <iostream.h>
#include "MyData.h"
template <class T>
void run(T* pData,int left,int right)
{
int i,j;
T middle,iTemp;
i = left;
j = right;
//下面的比较都调用我们重载的操作符函数
middle = pData[(left+right)/2]; //求中间值
do{
while((pData[i]<middle) && (i<right))//从左扫描大于中值的数
i++;
while((pData[j]>middle) && (j>left))//从右扫描大于中值的数
j--;
if(i<=j)//找到了一对值
{
//交换
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
}while(i<=j);//如果两边扫描的下标交错，就停止（完成一次）
//当左边部分有值(left<j)，递归左半边
if(left<j)
run(pData,left,j);
//当右边部分有值(right>i)，递归右半边
if(right>i)
run(pData,i,right);
}
template <class T>
void QuickSort(T* pData,int Count)
{
run(pData,0,Count-1);
}
void main()
{
CMyData data[] = {
CMyData(8,"xulion"),
CMyData(7,"sanzoo"),
CMyData(6,"wangjun"),
CMyData(5,"VCKBASE"),
CMyData(4,"jacky2000"),
CMyData(3,"cwally"),
CMyData(2,"VCUSER"),
CMyData(1,"isdong")
};
QuickSort(data,8);
for (int i=0;i<8;i++)
cout<<data[i].m_iIndex<<" "<<data[i].GetData()<<"\n";
cout<<"\n";
}

⑶ 图像拼接技术的图像拼接技术分类

图像拼接技术主要包括两个关键环节即图像配准和图像融合。对于图像融合部分，由于其耗时不太大，且现有的几种主要方法效果差别也不多，所以总体来说算法上比较成熟。而图像配准部分是整个图像拼接技术的核心部分，它直接关系到图像拼接算法的成功率和运行速度，因此配准算法的研究是多年来研究的重点。
目前的图像配准算法基本上可以分为两类:基于频域的方法(相位相关方法)和基于时域的方法。 基于时域的方法又可具体分为基于特征的方法和基于区域的方法。基于特征的方法首先找出两幅图像中的特征点(如边界点、拐点)，并确定图像间特征点的对应关系，然后利用这种对应关系找到两幅图像间的变换关系。这一类方法不直接利用图像的灰度信息，因而对光线变化不敏感，但对特征点对应关系的精确程度依赖很大。这一类方法采用的思想较为直观，大部分的图像配准算法都可以归为这一类。基于区域的方法是以一幅图像重叠区域中的一块作为模板，在另一幅图像中搜索与此模板最相似的匹配块，这种算法精度较高，但计算量过大。
按照匹配算法的具体实现又可以分为直接法和搜索法两大类，直接法主要包括变换优化法，它首先建立两幅待拼接图像间的变换模型，然后采用非线性迭代最小化算法直接计算出模型的变换参数，从而确定图像的配准位置。该算法效果较好，收敛速度较快，但是它要达到过程的收敛要求有较好的初始估计，如果初始估计不好，则会造成图像拼接的失败。搜索法主要是以一幅图像中的某些特征为依据，在另一幅图像中搜索最佳配准位置，常用的有比值匹配法，块匹配法和网格匹配法。比值匹配法是从一幅图像的重叠区域中部分相邻的两列上取出部分像素，然后以它们的比值作模板，在另一幅图像中搜索最佳匹配。这种算法计算量较小，但精度较低;块匹配法则是以一幅图像重叠区域中的一块作为模板，在另一幅图像中搜索与此模板最相似的匹配块，这种算法精度较高，但计算量过大;网格匹配法减小了块匹配法的计算量，它首先要进行粗匹配，每次水平或垂直移动一个步长，记录最佳匹配位置，然后在此位置附近进行精确匹配，每次步长减半，然后循环此过程直至步长减为0。这种算法较前两种运算量都有所减小，但在实际应用中仍然偏大，而且粗匹配时如果步长取的太大，很可能会造成较大的粗匹配误差，从而很难实现精确匹配。

⑷ 土建模板工程量怎么计算柱，梁，板，都怎么算求详细点的算法，公式…

土建模板工程量为柱，梁，板等构件量的总和。计算公式：垫层模板：S=1*4*0.1*2=0.8m2(周长 X 高 X 个数)，基础模板：S=0.8*4*0.45*2=2.89m2（周长 X 高 X 个数）。

基础柱模板：S=（0.4*4*0.6-0.4*0.3*2）*2=1.44m2（（周长 X 高 - 梁头接触部位面积）X 个数），梁模板：S=(0.3+0.4*2)*(4-0.2*2)=3.96m2（（底面 + 侧面 X 2) X 梁净长）。

在计算板底肋梁的时候，板底肋梁的模板计算高度为：梁截面高度--现浇板高度，故而出现楼主所说的同学在计算梁的模板的时候，扣除120（这个扣除的高度要看现浇板的厚度）。

着重一点：在现浇板外围的梁模板要计算全高，比如上面的，外围梁模板高度为0.4m，靠梁内侧高度为0.4-0.12=0.28m。

(4)分块算法模板扩展阅读：

建筑模板是一种临时性支护结构，按设计要求制作，使混凝土结构、构件按规定的位置、几何尺寸成形，保持其正确位置，并承受建筑模板自重及作用在其上的外部荷载，进行模板工程的目的，是保证混凝土工程质量与施工安全、加快施工进度和降低工程成本。

参考资料来源：网络-建筑模板

⑸ 线性代数c++模板库 eigen如何使用

http://blog.csdn.net/abcjennifer/article/details/7781936
正好刚在研究这个
多看看博客，仔细研究下

⑹ 大学的数学建模竞赛怎么准备

我在大二的时候就和室友一起参加过全国大学生数学建模竞赛，学校里也上过这方面的专业课，可以说对此有点自己的见解和建议。下面我想分享一下自己当时做的一些准备供你参考。

首先，肯定要学习数学模型方面的知识。

数学建模，顾名思义就是建立数学模型，需要你去了解一下常用的数学模型。有些同学可能会疑问，数学还有什么模型呢？不就是套套公式吗。其实不然，对于国赛，最常用的莫过于概率论与数理统计了。

当然，如果你学有余力的话，可以去学SPSS这种专业的统计软件，或者像Visio这样的绘图软件，在统计或者绘图等方面，用起来更加方面，图案也更加精美。

总而言之，对于大学的数学建模竞赛，还是需要好好准备的，无论是数学的专业知识还是算法的设计实现。如果能找到合适的队友，那么合作起来还是很轻松的，希望你能得到一个好成绩！

⑺ 网络蚂蚁的特点

网络蚂蚁的作者洪以容1973年7月一个不是很热的夏天出生在上海，1991年进入上海交通大学计算机系。95年毕业随后进入上海华腾软件有限公司，开始了自己正式的软件开发生涯。1998年考入上海交通大学计算机系系统结构专业，目前正在攻读研究生。在他拿到研究生录取通知书以后的那段时间里，他尝试开发出了现在着名的下载软件精品--网络蚂蚁。网络蚂蚁获得了巨大的成功，相继被国内外的软件下载站点和权威媒体评为优秀软件，得到了广大网民的认可和支持。

东东包第一次采访洪以容是在去年的10月底，当时是就软件作者之间的合作问题向洪先生询问看法。话筒里传过来的声音沉稳而冷静，一如波澜不兴的湖水。我知道那一定是一个出色的程序员不可或缺的素质，只有沉静的性情才能在枯燥乏味的程序编写过程中拥有摆脱外界诱惑的定力。第一次的印象浮光掠影，但是我的心里认为他是一个对技术有着宗教般虔诚的狂热爱好者。对于网络蚂蚁的发展和升级之路我进行了足够的关注。当另一个国产精品JETCAR(现在已经改名为Flashget)从众多的下载软件脱颖而出的时候，我们很多人都觉得这是一场棋逢对手的好戏。也许竞争带给蚂蚁了些许压力，不过蚂蚁的正式版还是拖到了今年的2月。正式版推出之日，东东包和伙伴们拍了拍手，大家眼神里都有着相同的看法：“终于出来了。”

蚂蚁的成功为洪带来了一笔可观的广告收入，还为他带来了良好的声誉和影响。但是出名的人往往会面对着巨大的压力和无数挑剔的目光。于是蚂蚁在成长的过程中开始要承受许多的批评和指责，尤其是网络蚂蚁的中文版问题和广告条问题，大家的批评甚至上升到了一个道德品格和民族感情的层面。面对责难，洪的心里有着不被常人所了解的痛苦和困惑，一种难以表白的抑郁。幸亏他的身边还有着深爱着他，支持着他的女友，还有着一大帮热情仗义的朋友。他咬着牙熬过了那段异常艰辛的时光。今天的他在繁重的课题研究之余，还在做着网络蚂蚁的维护工作和升级准备。他希望能把网络蚂蚁做成一个国产软件的精品，而且想把它推到国外去，让老外也用上我们中国人做的软件。

在逐渐的交往和了解的过程中，东东包感觉到应该把网络蚂蚁的作者的另一面呈现给大家。让大家了解到一个优秀的中国程序员的生活和思想，一些鲜为人知的小事情，一些不被人了解的酸甜苦辣，从而真正的认识而不是肤浅的臆测我们的软件精英们，他们的一切一切。我希望大家能够给他们多点鼓励和支持，多点宽容和善意，多点体贴和赞美，因为他们是我们走向世界的希望。(东东包)

（下面的文字由洪以容的女友Nunu和东东包共同完成，包括了洪以容自己的故事，他和女友的故事，他和妹妹的故事，他和朋友们的故事，希望大家喜欢。当然有些事情我现在还不能写，估计要五年之后才能写出来。：））

网络蚂蚁的成长过程其实也是网络蚂蚁作者洪以容个人的一个成长过程。在写网络蚂蚁之前洪以容在同事们的眼里只是一个比较高手的程序员，在父母眼里只是一个对计算机痴迷的儿子，如果不是在那一霎那他想到了多点续传的点子，如果不是他的好朋友婉拒了替他把这个主意写成代码（我先要说一句，他之所以想让别人写这个程序，是因为他比较“懒”，这是洪以容的一个鲜明的特点，在接下来的事情中很多对网络蚂蚁的意见都取决于它的这个特点），如果不是他正好在家里等着考研的结果，那也许到现在他也还是老样子。但是这三个条件都成立了，于是中国最好的下载软件 = 网络蚂蚁 = 洪以容这个等式就诞生了。

98年6月份第一个测试版本的网络蚂蚁出现在电脑之家的下载区。由于它的短小精悍和快速的下载功能，很快就在网络中散布开来。很快洪以容收到第一个用户的来信，于是从此开始了漫漫的升级之路。每天n次拨号，收email，回信，找bug，增加新功能，这些事情几乎成了他每天的工作。他的潜意识当中意识到他的新的一种生活方式到了，和以前的截然不同的一种生活。一个伟人曾经说过：站在巨人的肩上才能看得更远，他正是站在了Internet这个巨人的肩上才看到了那片天地。可是不懂电脑的父母难以理解儿子一天十几个小时坐在电脑前面，父母希望儿子能像别人家的孩子一样到社会上去为生活打拼，而不是夜以继日的和电脑相处。得不到理解的洪以容也很苦闷，因为这个时候网络蚂蚁也已经到了一个没有什么突破的地步，每天的用户来信越来越多，问的问题也大多数很简单，为了负责，他不得不化很多时间去回答用户的问题，而在开发方面，也只能对蚂蚁增加一些小的功能，修改一些小的bug。 显然这个时候的洪以容需要一些新的动力。

于是这个时候他的生命中出现了两个转折。

第一个转折当然就是我的出现。我，一个小小的女网虫，我们认识了，我们走到一起了。我也是一个程序员，所以有的时候还能提出一些很不错的建议，不过我最重要的功能就是可以帮他回信。网络蚂蚁的发展可以从我回信的这个侧面看出。刚开始的时候也就是98年12月份开始每天大概有十几封信，到99年年底，每天就要回四五十封，到2000年2月份网络蚂蚁1.0正式版推出的第一天， 回了100多封email,以后大概就保持在七十几封，这里我还要感谢Becky的作者（不管他是否看得到），他的email程序有模板的功能，我针对大多数用户都会提到的问题作了很多的模板，这就大大节省了我的回信时间。每次我们见面的时候，总是要讨论蚂蚁。可以增加一些什么功能啊，那些地方操作不方便啊。有一次我们在一起看Getright有什么新功能，见到它的readme里面的一段话：感谢为我录制声音的我的妹妹。我们听了一下，发现在增加任务，任务完成，出错的时候，都会出现一个小女孩的声音提示。我们都觉得这个功能很有趣，就决定自己也做一个，由我来读。翻箱倒柜的找出那个劣质的麦克风，然后录了“File added”“job compete”“something wrong”这三句话，简简单单的三句话，我们几乎录了一个小时，他总说我的发音不标准，为了满足他的要求，只能一遍遍重复，就象歌手在录音棚里遇到一个苛刻的制作人一样，等总算pass以后，我发觉我忘了中文怎么说了。：-）洪以容把这个功能加到新版本中去了，第一个版本很平静的过去了，没发生什么问题。第二个版本中他增加了批量下载的功能，就是按照一定规律一下子可以增加几百个任务的功能。这下问题来了，他写完代码，然后让我做测试，我在我的电脑上试了一下，就觉得速度奇慢，好几分钟以后才全部加入任务。我马上向洪以容报告，他找了半天也没有发觉问题在哪里。后来只能归咎于我的机器有问题。新版本发布了，问题却马上找到了，原来是开启了声音提示的功能，就是说每加入一个功能，我的声音“file added”就播放一边，几百个任务就会播放几百遍，能不慢吗？而我电脑上的喇叭关着，所以没有发觉问题。我们知道缘由，大笑之后，洪以容马上就进行了修改。

因为洪以容在读研究生，而我的工资也不高，所以我们的开销一向比较节省的。去年情人节，他只送了一块几块钱的巧克力，由此可见，我们的物质生活多么清平。：-（ 我们第一笔通过网络蚂蚁的收入是一个公司要出一张光盘，其中收录了网络蚂蚁，这个公司就象征性的付了2000元作为回报。我们都开心的不得了，还列了一个计划怎么去花这些钱，而我们的计划中包括了我们所有的亲人，他的父母妹妹，我的父母，于是每个人都得到了一件小小的礼物，这总算也是让他们知道了洪以容和我工作的一点价值把。但是钱很快就用完了，我们面临着新的问题，每个月高额的电话费和上网费。上海的ISP的速度之慢，还有收费之高是世人所皆知的问题。网络蚂蚁的开发过程中需要上网调试，才能找到问题所在，而且还需要到国外专门的站点去找技术资料，于是洪以容就想到了一个生财之道，仿照其他下载软件，在界面上放一个广告。这种做法遭到了很多网友的反对，有的干脆写信来问我们怎么破解这个广告条，于是我就告诉了他们我们的苦衷，还问他们如果他们了解我们处境以后还是想知道破解的办法，请再给我来信，我会告诉他们的。收到我的回信后，大多数网友都对我们的做法表示了理解。于是我们有了一笔固定的收入。第一笔的钱用于了网络蚂蚁的网站的建设，包括域名的注册，虚拟主机的租借，页面的制作。这就是大家现在看到的网络蚂蚁的那个网站。

在我眼中，洪以容是一个不折不扣的程序员，他对技术的追求几乎到了痴迷的程度，他的机器上装满了各种下载软件，每个软件的主要特色和实现方法他都了如指掌。他对自己写的程序的要求几乎是苛刻的，用几个小时或者几天写的程序只要稍微有些瑕疵，都会被他毫不留情的delete,他也会花很长时间用鼠标慢慢的点出一个符合他要求的小图标出来，只为了让他的程序看上去更精致、更专业。他对于Go!zilla的那套特制的图标简直到了垂涎的地步。幸好，他身边还有一个小助手，他的妹妹，他妹妹是一个美术编辑，大家看到蚂蚁的那个Icon了吗？这就是他妹妹的杰作，也是用鼠标慢慢点出来的。不过也真难为了他妹妹，从来都是用笔绘的她硬是在洪以容的威逼利诱之下，点出了一个小蚂蚁。有个用户来信，说道：现在下载软件很多，多点续传已经不再是网络蚂蚁的特色了，而且其它软件的下载文件管理，抢带宽能力都超过了网络蚂蚁。而他之所以还一直使用网络蚂蚁，就是觉得这个程序非常专业，每个细微之处都想的非常周到。关于这点洪以容自己也说过：我写的程序一般不会出什么大的错误，我考虑一个问题会想的非常全面。的确是这样的，当他想到要增加一个新功能，就会先化上很多时间把所有的改动，各方面要注意到的事情都在脑子里仔细想清楚，然后才会动手去做。就因为这样，网络蚂蚁遇上了诞生以来的第一件麻烦的事情。

这当然就是关于中文版的事情。洪以容其实是一个对自己的技术水平很骄傲的人，他觉得自己的程序完全可以和国外的一些知名的下载软件相比。而且他非常不能理解现在很多软件动不动就打着国产软件的牌子到处招摇这种情况,要用就要用好的软件，在这点上国产软件应该和国外的软件是平等的。 他希望用户是真的觉得他的软件好才使用的，而不仅仅因为写软件的作者是中国人。抱着这个思想，网络蚂蚁推出第一个版本的时候就是全英文的界面，当时很多用户也没有意识到这是个国产软件，所以也没什么事情发生。可是电脑报第一次采访了洪以容，第一次让大家知道网络蚂蚁其实是中国人的作品。于是事情就复杂了。一篇名为“别了，假洋鬼子”在网友中迅速传播着。文章中猛烈的批评网络蚂蚁采用全英文界面的现象。我记得很多热心的网友把这篇文章寄来，我看了以后觉得很气愤，洪以容为了写网络蚂蚁牺牲了那么多，付出了那么多，几乎每天他都要为网络蚂蚁作一些事情，不是改错误就是加功能。而且当时这个软件是完全免费的。作了那么多事情，还要被别人骂，我实在想不通，可是我把这件事情告诉洪以容以后，他却笑着说：“没什么啊，会提出这样的问题很正常，但是不能说我不爱国，英文界面和爱不爱国完全没有关系，要是说我懒，这点我倒是承认的。我写程序的时候采用的是单字节的处理方式，要改成双字节的，需要对程序作很大的修改。而且很大程度上是工作量的事情，不是技术上的，我还有很多新的功能没有做，所以一直懒的去做中文版。”后来虽然洪以容和那篇文章的作者取得了联系，并达成了共识，但是网络上这个问题还是闹得沸沸扬扬的。

这个时候，第二个转折点出现了，就是洪以容的朋友们：歪歪，关子等。歪歪是原电脑报软件版的主编，是电脑报采访洪以容的时候认识他的。两个都想为中国软件业做些事情的人，一联系上就成了好朋友。歪歪听说了这件事情，马上写了一篇文章帮洪以容澄清这个问题，而中国汉化同盟的关子也马上替洪以容做了中文版本。两个朋友一起替洪以容过了这关。其实在整个蚂蚁的成长过程中很多热心的网友也提供了很多的帮助，以前网络蚂蚁的网页就是一个网友川川替我们免费做的，日常的维护也都是他来完成的。还有一个网友建立了一个网络蚂蚁收藏馆（http://dzc.126.com），收藏了蚂蚁发布以来的所有版本，大家有空可以去光顾一下。有一个网友经常写信来提一些非常实用的建议，报告一些问题，我们一直以为是一个计算机水平很高的年轻人，就想和他联系一下，他来信告诉了电话，还说一般白天晚上都在家的，我们觉得很奇怪，打了电话过去，原来是一个已经退休的老者，怪不得总是在家呢。这位博学的老者帮了我们很多的忙，网络蚂蚁详细的帮助手册就是他制作的。

网络蚂蚁的发展并不是一帆风顺的，有些困难在我的帮助在朋友们的帮助下，就克服过去了，可是有些困难就一定要洪以容自己来面对了。其中最明显的例子就是网络蚂蚁的竞争对手FlashGet的出现。作为一个可以采用更多线程数、全中文的界面、方便的文件管理系统的下载软件，他一出现就给网络蚂蚁带来了很大的威胁，因为他几乎继承并发扬了网络蚂蚁所有的优点，而补充了网络蚂蚁最大的缺点。面临这样的局面，我们都帮不上忙了，只能看洪以容了。还好这个时候他还是有很强的自信，他说：这个软件的出现很正常，现在的世界就需要竞争，看着吧，我的网络蚂蚁才不会落后呢。从此这两个作者就暗暗的较上了劲，你出个新版本我也出一个，你加了一个新功能我也要加上，你没有的功能我也要加上，于是在竞争中这两个软件就一起变得成熟起来。这时候，洪以容又开始不满足了，现在不是流行强强联手吗？互联网的另一个精神不就是合作吗？所以他找到了Flashget的作者，两个作者一拍即合，想共同探索一条中国共享软件作者的合作之路出来。具体的结果如何？只能告诉大家一句话：预知后事如何，且听下回分解。

现在洪以容最大的心愿就是把网络蚂蚁重新写一遍，因为第一次写的时候没有经验，很多问题都没有考虑到，现在也很难修改， 最关键的地方是想重新写一个更加完善稳定的下载API，采用更加高效的分块算法，总之是为将来的升级发展打下坚实的基础。另外是要实现与第三方软件的接口，使得其他软件可以向网络蚂蚁加入新任务，获得下载任务的动态信息等。等这个时候，网络蚂蚁就真的可以超越国外的下载软件，从而走出国门，走向世界。