国产婷婷色一区二区三区在线,国产精品视频男人的天堂,亚洲综合电影

深入理解C语言(转coolshell)

Snape — Sun, 15 Jul 2012 22:10:00 GMT

摘要: Dennis Ritchie �q�世了，他发明了C语言�Q�一个媄响深�q��ƈ��d��改变世界的计��机语言。一门经�?0多年的到今天�q�长盛不衰的语言�Q�今天很多语�a�都受到C的媄响，C++�Q�Java�Q�C#�Q�Perl�Q?PHP�Q?Javascript�Q?�{�等。但是，你对C了解吗？�怿�你看�q�本站的《C语言的谜题》还有《谁说C语言很简单？》，�q�里�Q�我再写一��关于深入理解C语言的文章，一斚w��是缅怀Dennis�Q?.. 阅读全文

Snape 2012-07-16 06:10 发表评论

�E�序员的奋斗�Ԍ��一�Q�——浅谈几�U�主要编�E�语�a�(�?

Snape — Sun, 08 Apr 2012 18:06:00 GMT

�E�序员的奋斗�Ԍ��一�Q?#8212;—��谈几种主要�~�程语言

分类�Q?nbsp;Others2012-04-04 15:36 8321人阅�?/span> 评论(87) 收藏举报

�l�常听到有�h在抱怨这个语�a�哪里哪里不好�Q�那个语�a�又是如何的优�U�。对于这��L��牢骚�Q�我只是一�W�而过�?/span>

��我而言�Q�语�a�只是工具�Q�没有好坏之分。只要你采用相应的语�a��Q�完成对应的工作�Q�那你的目标��完成了。我们无需抱怨这�U�语�a�的缺点，而是应该抱有接受的态度。�Q何语�a�的存在都有它的合理性，如果不合理是不会�l�受住时间的考验的。世间之物都��h��双面性，只是看利多还是弊大。如果一个东西是十全十美的，那我毫不犹��U的告诉你�Q�一�U�情冉|��它不存在�Q�另一�U�情冉|��你还没发现它的缺炏V�?/span>

每种语言都有自己得天独厚的优势，当然�~�点同时伴存�?span style="font-family: Calibri; ">C语言是计��机界的帔R��藤�?span style="font-family: Calibri; ">C语言执行效率高，用于写底层的驱动那是再适合不过。指针是C语言的精华。�?span style="font-family: Calibri; ">C++是很强大的，只要你是个高手，你几乎可以利�?span style="font-family: Calibri; ">C++完成��M��事情。当然虚函数�?span style="font-family: Calibri; ">C++的精华�?span style="font-family: Calibri; ">Java取消了指针，�q�是应该喜还是忧。喜的是�Q�没�?span style="font-family: Calibri; ">C或�?span style="font-family: Calibri; ">C++那种对内存繁琐的操作�Q�而且也降低了很多致命性的错误发生的概率。忧的是�Q�效率大打折扣，采用虚拟机的方式使得Java有跨�q�_��的特性，必然会��得效率降低。另外一个方面，你借别人的东西使用�Q�内存）�Q�是不是应该�q�回��d��Q�从�q�一斚w��考虑�Q?span style="font-family: Calibri; ">C或�?span style="font-family: Calibri; ">C++的设计思想更有意义。经常关�?span style="font-family: Calibri; ">TIOBE世界�~�程语言排行榜，Java已经有很久排名第一�Q�我觉得�q�样的排名只是看看而已�Q�无需�q�多的信奉。下面看看几�U�主要语�a�的优�~�点�?/span>

C语言

C语言的优点：

1.��z�紧凑、灵�z�L��?/span>

2.�q�算�W�丰�?/span>

3.数据�l�构丰富

4. C是结构式语言

5. C语法限制不太严格�Q�程序设计自由度�?/span>

6. C语言允许直接讉K��物理地址�Q�可以直接对��g�q�行操作

7. C语言�E�序生成代码质量高，�E�序执行效率�?/span>

8. C语言适用范围大，可移植性好

9. C语言有一个突出的优点��是适合于多�U�操作系�l?span style="font-family: Calibri; ">,�?span style="font-family: Calibri; ">DOS�?span style="font-family: Calibri; ">UNIX,也适用于多�U�机�?/span>

10.有效地将一个较复杂的程序系�l�设计�Q务分解成许多易于控制和处理的子�Q务，便于开发和�l�护

C语言的缺点：

1. C语言的缺点主要是表现在数据的��装性上�Q�这一点��?span style="font-family: Calibri; ">C在数据的安全性上做的有很大缺��P��q�也�?span style="font-family: Calibri; ">C�?span style="font-family: Calibri; ">C++的一大区别�?/span>

2. C语言的语法限制不太严��|��对变量的�c�d��U�束不严��|��影响�E�序的安全性，�Ҏ��l�下标越界不作检查等。从应用的角度，C语言比其他高�U�语�a�较难掌握�?/span>

3.可重用性差

4.数据安全性差

5.难以开发大型��Y件和囑�Ş界面的应用��Y�?/span>

6.把数据和处理数据的过�E�分��Mؓ�怺�独立的实�?/span>

7.当数据结构改变时�Q�所有相关的处理�q�程都要�q�行相应的修�?/span>

8.每一�U�相对于老问题的新方法都要带来额外的开销

9.囑�Ş用户界面的应用程序，很难用过�E�来描述和实玎ͼ�开发和�l�护也都很困�?/span>

C++

C++优点�Q?/span>

1.可扩展性强

2.高效 ��z?快�?/span>

3.可移植�?/span>

4.面向对象的特�?/span>

5.强大而灵�zȝ��表达能力和不输于C的效�?/span>

6.支持��g开�?br />7.�E�序模块间的关系更�ؓ��单，�E�序模块的独立性、数据的安全性就有了良好的保�?/span>

8.通过�l�承与多态性，可以大大提高�E�序的可重用性，使得软�g的开发和�l�护都更为方�?/span>

C++�~�点�Q?/span>

1.比较底层�Q�易用性不是很�?/span>

2.多重�l�承和友元机�?/span>

3.标准库涵盖范围不��?br />4.开发周期长

5.非�ƈ�?/span>

6.掌握有难�?/span>

7.�_�度��装不够

Java

Java的优点：

1.��单�?/span>

2.面向对象性（面向对象的程度可以达�?5%�Q?/span>

3.健壮�?/span>

4.跨��^台�?/span>

5.高性能�Q�自动垃圑֛�收机�Ӟ��

6.多线�E?/span>

7.动态�?/span>

8.安全�?/span>

Java的缺点：

1.效率低（毋庸�|�疑�Q?/span>

2.跨��^台是它最大的优点也是最大的�~�点

3.复杂性（做一个项目需要很多的知识�Q�涉及面�q�）

很多时候，一�U�语�a�的优点很可能是它的缺点，�~�点又可能是它的优点。这主要看你是从哪方面去考虑。这��印证了那句话，凡事没有必然�?/span>

不管是哪�U�语�a��Q�就像文章开头所�a��Q�只要你采用他达��C��惌��的，那就成功了。无需�q�多在意它的�~�点�Q�更无需赞扬它的优点。所以网上那些关于哪�U�语�a�更好的口水仗�Q�我只能说这��L��争斗毫无意义�?/span>

语言只是工具�Q�没有好坏之�?/span>

Snape 2012-04-09 02:06 发表评论

Snape — Sun, 01 Apr 2012 00:15:00 GMT

�c�间的关�p?/a>

�|�上关于此类的讨论非常多�Q�发现对于该问题的理解各有各的说法，而各个说法中又相�ȝ��q�。通过��览�q�些讨论以及寏V��O'Reilly - UML 2.0 In A Nutshell (2007)》的参考，发表一下自��q��看法

�c�间关系有很多种�Q�在大的�c�d��上可以分��Z��U�：�U�向关系、横向关�p�R�?/p>

�U�向关系��是�l�承关系�Q�它的概念非常明��，也成为OO的三个重要特征之一�Q�这里不�q�多的讨论�?/p>

横向关系较�ؓ微妙�Q�按照UML的徏议大体上可以分�ؓ四种�Q?/p>

依赖 �Q�Dependency�Q?/li>
兌�� Q�Association�Q?/li>
聚合 �Q�Aggregation�Q?/li>
�l�合 �Q�Composition�Q?/li>

它们的强弱关�p�L��没有异议的：依赖 < 兌�� < 聚合 < �l�合

然而它们四个之间的差别却又不那么好拿捏�Q�需要好好体会�?/p>

依赖�Q?ul style="list-style-type: disc; margin-left: 45px; ">
UML表示法：虚线 + ��头
关系�Q? ... uses a ..."
此关�p�L��为简单，也最好理解，所谓依赖就是某个对象的功能依赖于另外的某个对象�Q�而被依赖的对象只是作��Z��U�工具在使用�Q�而�ƈ不持有对它的引用�?/li>
典型的例子很多，比如�Q?br />class Human
{
    public void breath()
    {
        Air freshAir = new Air();
        freshAir.releasePower();
    }
    public static void main()
    {
        Human me = new Human();
        while(true)
        {
            me.breath();
        }
    }
}

class Air
{
    public void releasePower()
    {
        //do sth.
    }
}
释义�Q�一个�h自创生就需要不停的呼吸�Q�而�h的呼吸功能之所以能�l�持生命��在于吸�q�来的气体发挥了作用�Q�所以说�I�气只不�q�是人类的一个工��P��而�h�q�不持有对它的引用�?/li>
兌���Q?ul style="list-style-type: disc; margin-left: 45px; ">
UML表示法：实线 + ��头
关系�Q? ... has a ..."
所谓关联就是某个对象会长期的持有另一个对象的引用�Q�而二者的兌��往往也是�怺�的。关联的两个对象彼此间没有�Q何强制性的�U�束�Q�只要二者同意，可以随时解除关系或是�q�行兌��Q�它们在生命期问题上没有��M��U�定。被兌��的对象还可以再被别的对象兌��Q�所以关联是可以�׃�n的�?/li>
典型的例子很多，比如�Q?br />class Human
{
    ArrayList friends = new ArrayList();
    public void makeFriend(Human human)
    {
        friends.add(human);
    }
    public static void main()
    {
        Human me = new Human();
        while(true)
        {
            me.makeFriend(mySchool.getStudent());
        }
    }
}
释义�Q��h从生��x��都在不断的交朋友�Q�然而没有理��p��为朋友的生死与我的生��L��必然的联�p�，故他们的生命期没有关联，我的朋友又可以是别�h的朋友，所以朋友可以共享�?/li>
聚合�Q?nbsp;
- UML表示法：�I�心菱�Ş + 实线 + ��头
- 关系�Q? ... owns a ..."
- 聚合是强版本的关联。它暗含着一�U�所属关�p�M��及生命期关系。被聚合的对象还可以再被别的对象兌��Q�所以被聚合对象是可以共享的。虽然是�׃�n的，聚合代表的是一�U�更亲密的关�p�R�?/li>
- 典型的例子很多，比如�Q?br />class Human
  {
      Home myHome;
      public void goHome()
      {
          //在回家的路上
          myHome.openDoor();
          //看电�?br />    }
      public static void main()
      {
          Human me = new Human();
          while(true)
          {
              //上学
              //吃饭
              me.goHome();
          }
      }
  }
- 释义�Q�我的家和我之间��h��着一�U�强烈的所属关�p�，我的家是可以分��n的，而这里的分��n又可以有两种。其一是聚合间的分享，�q�正如你和你媛_��儉K��对这个家有着同样的强烈关联；其二是聚合与兌��的分享，如果你的朋友来家里吃个便饭，估计你不会给他配一把钥匙�?/li>
�l�合�Q?ul style="list-style-type: disc; margin-left: 45px; ">
UML表示法：实心菱�Ş + 实线 + ��头
关系�Q? ... is a part of ..."
�l�合是关�p�d��中的最强版本，它直接要求包含对象对被包含对象的拥有以及包含对象与被包含对象生命期的关系。被包含的对象还可以再被别的对象兌��Q�所以被包含对象是可以共享的�Q�然而绝不存在两个包含对象对同一个被包含对象的共享�?/li>
典型的例子很多，比如�Q?br />class Human
{
    Heart myHeart = new Heart();
    public static void main()
    {
        Human me = new Human();
        while(true)
        {
            myHeart.beat();
        }
    }
}
释义�Q�组合关�p�d��是整体与部分的关�p�，部分属于整体�Q�整体不存在�Q�部分一定不存在�Q�然而部分不存在整体是可以存在的�Q�说的更明确一些就是部分必��d��生于整体创生之后�Q�而销毁于整体销毁之前。部分在�q�个生命期内可以被其它对象关联甚臌��合，但有一点必��L��意，一旦部分所属于的整体销毁了�Q�那么与之关联的对象中的引用��׃��成�ؓ�I�引用，�q�一点可以利用程序来保障。心脏的生命期与人的生命期是一致的�Q�如果换个部分就不那么一定，比如阑尾�Q�很多�h在创生后的某个时间对其厌倦便提前销毁了它，可它和�h�cȝ��关系不可辩驳的属于组合�?br />在UML中存在一�U�特例，��是允许被包含对象在包含对象销毁前转移�l�新的对象，�q�虽然不自然�Q�但它给需要心脏移植的患者带来了��音�?/li>

Snape 2012-04-01 08:15 发表评论

Snape — Sat, 31 Mar 2012 23:57:00 GMT

摘要: 教你文本聚类2009-08-23 18:32 189人阅�?nbsp;评论(0) 收藏举报�?要：文本聚类是搜索引擎和语义web的基本技术，�q�次本蛙和大家一起学习一下简单的文本聚类��法�Q�可能不能直接用于实际应用中�Q�但对于惛_��搜烦技术的初学者还是有一定入门作用的。这里会用到TF/IDF权重�Q�用余��u夹角计算文本�怼�度，用方差计��两个数据间�Ƨ式距离�Q�用k-means�q�行... 阅读全文

Snape 2012-04-01 07:57 发表评论

字符串相似度��法介绍(整理)(�?

Snape — Sat, 31 Mar 2012 23:52:00 GMT

最�q�在做这斚w��的应用，把我扑ֈ�的资料脓出来�Q�有需要的人可以参考参考�?br />1�Q�编辑距��（Levenshtein Distance�Q?br />�~�辑距离��是用来计算从原�Ԍ��s�Q��{换到目标�?t)所需要的最��的插入�Q�删除和替换
的数目，在NLP中应用比较广泛，如一些评��方法中��q��C��Q�wer,mWer�{�）�Q�同时也常用来计��你对原文本所作的改动数。编辑距��ȝ��法是首先由俄国�U�学家Levenshtein提出的，故又叫Levenshtein Distance�?br />Levenshtein Distance��法可以看作动态规划。它的思�\��是从两个字�W�串的左边开始比�?记录已经比较�q�的子串�怼��?实际上叫做距��?,然后�q�一步得��C��一�?字符位置时的�怼�度�?用下面的例子: GUMBO和GAMBOL。当��到矩阵D[3,3]位置�?也就是当比较到GUM和GAM�?要从已经比较�q�的3对子串GU-GAM, GUM-GA和GU-GA之中选一个差别最��的来当它的�? 所以要从左上到右下构造矩��c�?br />�~�辑距离的伪��法�Q?br />整数 Levenshtein距离(字符 str1[1..lenStr1], 字符 str2[1..lenStr2])
   宣告 int d[0..lenStr1, 0..lenStr2]
   宣告 int i, j, cost

   对于 i �{�于 �?0 �?lenStr1
       d[i, 0] := i
   对于 j �{�于 �?0 �?lenStr2
       d[0, j] := j
   对于 i �{�于 �?1 �?lenStr1
       对于 j �{�于 �?1 �?lenStr2
           �?str1[i] = str2[j] �?cost := 0
                                否则 cost := 1
           d[i, j] := 最��?
                                d[i-1, j ] + 1,     // 删除
                                d[i , j-1] + 1,     // 插入
                                d[i-1, j-1] + cost   // 替换
                            )
�q�回 d[lenStr1, lenStr2]

double Minimum(double a, double b, double c)
{
double mi;

mi = a;
if (b < mi) {
mi = b;
}
if (c < mi) {
mi = c;
}
return mi;
}

int* GetCellPointer(int *pOrigin, int col, int row, int nCols)
{
return pOrigin + col + (row * (nCols + 1));
}

int GetAt(int *pOrigin, int col, int row, int nCols)
{
int *pCell;

pCell = GetCellPointer (pOrigin, col, row, nCols);
return *pCell;
}

void PutAt(int *pOrigin, int col, int row, int nCols, double x)
{
int *pCell;
pCell = GetCellPointer (pOrigin, col, row, nCols);
*pCell = x;
}

//�~�辑距离
LD(const char *s, const char *t)
{
int *d; // pointer to matrix
int n; // length of s
int m; // length of t
int i; // iterates through s
int j; // iterates through t
char s_i1; // ith character of s
char s_i2; // ith character of s
char t_j1; // jth character of t
char t_j2; // jth character of t
int *cost; // cost代�h矩阵
int result; // result
int cell; // contents of target cell
int above; // contents of cell immediately above
int left; // contents of cell immediately to left
int diag; // contents of cell immediately above and to left
int sz; // number of cells in matrix

// Step 1

n = strlen (s);
m = strlen (t);
if (n == 0)
{
return m;
}
if (m == 0)
{
return n;
}
sz = (n+1) * (m+1) * sizeof (int);
d = (int *) malloc (sz);
cost = (int *) malloc (sz);

// Step 2

for (i = 0; i <= n; i++)
{
PutAt (d, i, 0, n, i);
}

for (j = 0; j <= m; j++)
{
PutAt (d, 0, j, n, j);
}
for (int g=0;g<=m;g++)//把代仯��ȝ��阵全部初始化为同一个��|��以后可根据此值判断相应的�Ҏ��是否被赋�q��?br /> {
for(int h=0;h<=n;h++)
{
PutAt(cost,h,g,n,2);
}
}
// Step 3

for (i = 1; i <= n; i++)
{

s_i1 = s[i-1];
s_i2 = s[i];
bool sbd=false;
bool tbd=false;
if(s_i1>=' '&&s_i1<='@'||s_i1>='A'&&s_i1<='~' )
{//s为标点符��h��其他非中文符号和数字
sbd=true;
}
// Step 4

for (j = 1; j <= m; j++)
{

   tbd=false;
   t_j1 = t[j-1];
   t_j2 = t[j];
   // Step 5
   if(t_j1>=' '&&t_j1<='@'||t_j1>='A'&&t_j1<='~' )
   {//t也�ؓ标点�W�号
    tbd=true;
   }
   if(!sbd)
   {//s为汉�?br />    if(!tbd)
    {//t也�ؓ汉字
     if (s_i1 == t_j1&&s_i2 == t_j2)
     {
      bool tt=false;
      int temp=GetAt(cost,i,j,n);
      if(temp==2)
      {
       PutAt(cost,i,j,n,0);
       tt=true;
      }
      if(tt)
      {//因�ؓst全市汉字�Q�所以把代�h矩阵他相�ȝ��未赋�q�值的三个��D��?br />       int temp1=GetAt(cost,i+1,j,n);
       if(temp1==2)
       {
        PutAt(cost,i+1,j,n,0);
       }
       int temp2=GetAt(cost,i,j+1,n);
       if(temp2==2)
       {
        PutAt(cost,i,j+1,n,0);
       }
       int temp3=GetAt(cost,i+1,j+1,n);
       if(temp3==2)
       {
        PutAt(cost,i+1,j+1,n,0);
       }
      }
     }
     else
     {
      bool tt=false;
      int temp=GetAt(cost,i,j,n);
      if(temp==2)
      {
       PutAt(cost,i,j,n,1);
       tt=true;
      }
      if(tt)
      {
       int temp1=GetAt(cost,i+1,j,n);
       if(temp1==2)
       {
        PutAt(cost,i+1,j,n,1);
       }
       int temp2=GetAt(cost,i,j+1,n);
       if(temp2==2)
       {
        PutAt(cost,i,j+1,n,1);
       }
       int temp3=GetAt(cost,i+1,j+1,n);
       if(temp3==2)
       {
        PutAt(cost,i+1,j+1,n,1);
       }
      }
     }
    }
    else
    {//t为符�?br />     bool tt=false;
     int temp=GetAt(cost,i,j,n);
     if(temp==2)
     {
      PutAt(cost,i,j,n,1);
      tt=true;
     }
     if(tt)
     {
      int temp1=GetAt(cost,i+1,j,n);
      if(temp1==2)
      {
       PutAt(cost,i+1,j,n,1);
      }
     }

    }

   }
   else
   {//s为符�?br />    if(!tbd)
    {//t为汉�?nbsp;
     bool tt=false;
     int temp=GetAt(cost,i,j,n);
     if(temp==2)
     {
      PutAt(cost,i,j,n,1);
      tt=true;
     }
     if(tt)
     {
      int temp1=GetAt(cost,i,j+1,n);
      if(temp1==2)
      {
       PutAt(cost,i,j+1,n,1);
      }
     }
    }
    else
    {
     if(s_i1==t_j1)
     {
      int temp=GetAt(cost,i,j,n);
      if(temp==2)
      {
       PutAt(cost,i,j,n,0);
      }
     }
     else
     {
      int temp=GetAt(cost,i,j,n);
      if(temp==2)
      {
       PutAt(cost,i,j,n,1);
      }
     }
    }

}

// Step 6

   above = GetAt (d,i-1,j, n);
   left = GetAt (d,i, j-1, n);
   diag = GetAt (d, i-1,j-1, n);
   int curcost=GetAt(cost,i,j,n);
   cell = Minimum (above + 1, left + 1, diag + curcost);
   PutAt (d, i, j, n, cell);
}
}

// Step 7

result = GetAt (d, n, m, n);
free (d);
return result;

}

2�Q�最长公共子�?(LCS)
LCS问题��是求两个字�W�串最长公共子串的问题。解法就是用一个矩阉|��记录两个字符
串中所有位�|�的两个字符之间的匹配情况，若是匚w��则�ؓ1�Q�否则�ؓ0。然后求出对角线最长的1序列�Q�其对应的位�|�就是最长匹配子串的位置.
下面是字�W�串21232523311324和字�W�串312123223445的匹配矩阵，前者�ؓX方向的，
后者�ؓY方向的。不难找刎ͼ��U�色部分是最长的匚w��子串。通过查找位置我们得到最长的匚w��子串为：21232
0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
　　0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
　　1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
　　0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
　　1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
　　0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
　　1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
　　1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
　　0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
　　0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
　　0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
　　0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
　　0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
但是�?�?的矩阵中找最长的1对角�U�序列又要花��M��定的旉��。通过改进矩阵的生成方式和讄��标记变量�Q�可以省去这部分旉��。下面是新的矩阵生成方式�Q?br /> 0 0 0 1 0 0 0 1 1 0 0 1 0 0 0
　　0 1 0 0 0 0 0 0 0 2 1 0 0 0 0
　　1 0 2 0 1 0 1 0 0 0 0 0 1 0 0
　　0 2 0 0 0 0 0 0 0 1 1 0 0 0 0
　　1 0 3 0 1 0 1 0 0 0 0 0 1 0 0
　　0 0 0 4 0 0 0 2 1 0 0 1 0 0 0
　　1 0 1 0 5 0 1 0 0 0 0 0 2 0 0
　　1 0 1 0 1 0 1 0 0 0 0 0 1 0 0
　　0 0 0 2 0 0 0 2 1 0 0 1 0 0 0
　　0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
　　0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
　　0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
　　0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
�?字符匚w��的时候，我们�q�不是简单的�l�相应元素赋�?�Q�而是赋上其左上角元素的值加一。我们用两个标记变量来标记矩阵中值最大的元素的位�|�，在矩�는�成的�q?�E�中来判断当前生成的元素的值是不是最大的�Q�据此来改变标记变量的��|��那么到矩阵完成的时候，最长匹配子串的位置和长度就已经出来了�?/p>

//最长公共子�?br />char* LCS(char*left,char* right){
int lenLeft,lenRight;
lenLeft = strlen(left);
lenRight = strlen(right);
int *c = new int[lenRight];
int start,end,len;
end = len = 0;
for(int i = 0; i < lenLeft; i++){
for(int j = lenRight-1; j >= 0; j--){
   if(left[i] == right[j]){
    if(i == 0 || j == 0)
     c[j] = 1;
    else
     c[j] = c[j-1]+1;
   }
   else
    c[j] = 0;
   if(c[j] > len){
    len = c[j];
    end = j;
   }
}
}
char *p = new char[len+1];
start = end - len + 1;
for(i = start; i <= end; i++)
p[i - start] = right[i];
p[len] = '/0';
return p;
}
3. 余��u定理 (向量�I�间��法)
余��u定理古老而广泛的数学概念�Q�在各个学科及实践中都得��C��大量的应用，�q�里��单的介绍下其在判断两个字�W�串�怼�度的应用�?br />在余弦定理中基本的公式�ؓ�Q?/p>

假如字符串s1与s2�Q�比较两个字�W�串的相似度�Q�sim(s1,s2)�Q�假设s1,s2中含有n个不同的字符�Q�其分别为c1,c2,...cn�Q�判断字�W�串的相似度转换��Z��个字�W�串对应的向量v1,v2之间夹角大小的判断，余��u��D��大其向量之间的夹角越��，s1与S2的相似度��大�?br />向量�I�间��法的介�l�：
�?向量�I�间模型中，文本泛指各种机器可读的记录。用D�Q�Document�Q�表�C�，特征��（Term�Q�用t表示�Q�是指出现在文档D中且能够代表该文档内容的�?本语�a�单位�Q�主要是��p��或者短语构成，文本可以用特征项集表�C�ZؓD(T1�Q�T2�Q?#8230;�Q�Tn)�Q�其中Tk是特征项�Q?<=k<=N。例如一��文档中有a、b、c、d四个特征��，那么�q�篇文档��可以表�C�ZؓD(a�Q�b�Q�c�Q�d)。对含有n个特征项的文本而言�Q�通常会给每个特征��赋予一定的权重表示�?重要�E�度。即D�Q�D(T1�Q�W1�Q�T2�Q�W2�Q?#8230;�Q�Tn�Q�Wn)�Q�简��CؓD�Q�D(W1�Q�W2�Q?#8230;�Q�Wn)�Q�我们把它叫做文本D的向量表�C�。其中Wk是Tk 的权重，1<=k<=N。在上面那个例子中，假设a、b、c、d的权重分别�ؓ30�Q?0�Q?0�Q?0�Q�那么该文本的向量表�C�Zؓ D(30�Q?0�Q?0�Q?0)。在向量�I�间模型中，两个文本D1和D2之间的内容相兛_��Sim(D1�Q�D2)常用向量之间夹角的余弦��D��C�，公式为：

其中�Q�W1k、W2k分别表示文本D1和D2�W�K个特征项的权��|��1<=k<=N。我们可以利用类似的�Ҏ��来计��两个字�W�串的相兛_��?nbsp;
�q�个��法�|�上没找刎ͼ�虽然我写�q�，但是没什么通用性，��׃��贴出来。很��单的�Q�有兴趣的可以自己写一个�?/p>

Snape 2012-04-01 07:52 发表评论

Snape — Sat, 31 Mar 2012 23:41:00 GMT

【�{】面向对象设计中的经验原�?/a>

(1)所有数据都应该隐藏在所在的�cȝ��内部�?/span>

(2)�cȝ��使用者必��M��赖类的共有接口，但类不能依赖它的使用者�?/span>

(3)��量减少�cȝ��协议中的消息�?/span>

(4)实现所有类都理解的最基本公有接口[例如�Q�拷贝操�?深拷贝和��拷�?、相�{�性判断、正��输出内宏V��从ASCII描述解析�{�等]�?/span>

(5)不要把实现细�?例如攄��q��代码的私有函�?攑ֈ��cȝ��公有接口中。如果类的两个方法有一�D�公�׃��码，那么��可以创��Z��个防止这些公�׃��码的�U�有函数�?/span>

(6)不要以用��h��法��用或不感兴趣的东西扰��q��的公有接口�?/span>

(7)�c�M��间应该零耦合�Q�或者只有导��合关系。也卻I��一个类要么同另一个类毫无关系�Q�要么只使用另一个类的公有接口中的操作�?/span>

(8)�c�d��该只表示一个关键抽象。包中的所有类对于同一�c�L��质的变化应该是共同��闭的。一个变化若对一个包影响�Q�则��对包中的所有类产生影响�Q�而对其他的包不造成��M��影响�?/span>

(11)��保你�ؓ之徏模的抽象概念是类�Q�而不只是对象扮演的角艌Ӏ?/span>

(12)在水�q�x��向上��可能统一地分布系�l�功能，也即�Q�按照设计，��层�c�d��当统一地共享工作�?/span>

(13)在你的系�l�中不要创徏全能�c?对象。对名字包含Driver、Manager、System、Susystem的类要特别多加小心。规划一个接口而不是实��C��个接口�?/span>

(14)对公共接口中定义了大量访问方法的�c�d��加小心。大量访问方法意味着相关数据和行为没有集中存放�?/span>

(15)对包含太多互不沟通的行�ؓ的类多加��心。这个问题的另一表现是在你的应用�E�序中的�cȝ��公有接口中创��Z��很多的get和set函数�?/span>

(16)在由同用��L��面交互的面向对象模型构成的应用程序中�Q�模型不应该依赖于界面，界面则应当依赖于模型�?/span>

(17)��可能地按照现实世界建模(我们常常��Z��遵守�pȝ��功能分布原则、避免全能类原则以及集中攄��相关数据和行为的原则而违背这条原�? �?/span>

(18)从你的设计中去除不需要的�c�R��一般来��_��我们会把�q�个�c�降�U�成一个属性�?/span>

(19)去除�pȝ��外的�c�R��系�l�外的类的特�Ҏ��Q�抽象地看它们只往�pȝ��领域发送消息但�q�不接受�pȝ��领域内其他类发出的消息�?/span>

(20)不要把操作变成类。质疑�Q何名字是动词或者派生自动词的类�Q�特别是只有一个有意义行�ؓ的类。考虑一下那个有意义的行为是否应当迁�U�d��已经存在或者尚未发现的某个�c�M��?/span>

(21)我们在创建应用程序的分析模型时常常引入代理类。在设计阶段�Q�我们常会发现很多代理没有用的，应当去除�?/span>

(22)��量减少�cȝ��协作者的数量。一个类用到的其他类的数目应当尽量少�?/span>

(23)��量减少�c�d��协作者之间传递的消息的数量�?/span>

(24)��量减少�c�d��协作者之间的协作量，也即�Q�减��类和协作者之间传递的不同消息的数量�?/span>

(25)��量减少�cȝ��扇出�Q�也卻I��减少�c�d��义的消息数和发送的消息数的乘积�?/span>

(26)如果�c�d��含另一个类的对象，那么包含�c�d��当给被包含的对象发送消息。也卻I��包含关系��L��意味着使用关系�?/span>

(27)�c�M��定义的大多数�Ҏ��都应当在大多数时间里使用大多数数据成员�?/span>

(28)�c�d��含的对象数目不应当超�q�开发者短期记忆的定w��。这个数目常常是6。当�c�d��含多�?个数据成员时�Q�可以把逻辑相关的数据成员划分�ؓ一�l�，然后用一个新的包含类��d��含这一�l�成员�?/span>

(29)让系�l�功能在�H�而深的��承体�p�M��垂直分布�?/span>

(30)在实现语义约束时�Q�最好根据类定义来实现。这常常会导致类泛滥成灾�Q�在�q�种情况下，�U�束应当在类的行��Z��实现�Q�通常是在构造函��C��实现�Q�但不是必须如此�?/span>

(31)在类的构造函��C��实现语义�U�束�Ӟ��把约束测试放在构造函数领域所允许的尽量深的包含层�ơ中�?/span>

(32)�U�束所依赖的语义信息如果经常改变，那么最好放在一个集中式的第3方对象中�?/span>

(33)�U�束所依赖的语义信息如果很��改变，那么最好分布在�U�束所涉及的各个类中�?/span>

(34)�c�d��ȝ��道它包含什么，但是不能知道谁包含它�?/span>

(35)�׃�n字面范围(也就是被同一个类所包含)的对象相互之间不应当有��用关�p�R�?/span>

(36)�l�承只应被用来�ؓ特化层次�l�构建模�?/span>

(37)�z��c�d��ȝ��道基�c�，基类不应该知道关于它们的�z��cȝ��M��信息�?/span>

(38)基类中的所有数据都应当是私有的�Q�不要��用保护数据。类的设计者永�q�都不应该把�cȝ��使用者不需要的东西攑֜�公有接口中�?/span>

(39)在理��Z��Q��承层�ơ体�p�d��当深一点，��深��好�?/span>

(40)在实践中�Q��承层�ơ体�pȝ��深度不应当超��Z��个普通�h的短期记忆能力。一个广为接受的深度值是6�?/span>

(41)所有的抽象�c�都应当是基�c�R�?/span>

(42)所有的基类都应当是抽象�c�R�?/span>

(43)把数据、行为和/或接口的共性尽可能地放到��承层�ơ体�pȝ��高端�?/span>

(47)对对象类型的昄��的分情况分析一般是错误的。在大多数这��L��情况下，设计者应当��用多态�?/span>

(48)对属性值的昄��的分情况分析常常是错误的。类应当解耦合成一个��承层�ơ结构，每个属性值都被变换成一个派生类�?/span>

(49)不要通过�l�承关系来�ؓ�cȝ��动态语义徏模。试囄��静态语义关�p�L��为动态语义徏模会��D��在运行时切换�c�d��?/span>

(50)不要把类的对象变成派生类。对��M��只有一个实例的�z��c�都要多加小心�?/span>

(51)如果你觉得需要在�q�行时刻创徏新的�c�，那么退后一步以认清你要创徏的是对象。现在，把这些对象概括成一个类�?/span>

(52)在派生类中用�I�方�?也就是什么也不做的方�?来覆写基�c�M��的方法应当是非法的�?/span>

(53)不要把可选包含同对��承的需要相��h��。把可选包含徏模成�l�承会带来泛滥成灄��c�R�?/span>

(54)在创建��承层�ơ时�Q�试着创徏可复用的框架�Q�而不是可复用的组件�?/span>

(55)如果你在设计中��用了多重�l�承�Q�先假设你犯了错误。如果没犯错误，你需要设法证明�?/span>

(56)只要在面向对象设计中用到了��承，问自�׃��个问题：(1)�z��c�L��否是它��承的那个东西的一个特�D�类型？(2)基类是不是派生类的一部分�Q?/span>

(57)如果你在一个面向对象设计中发现了多重��承关�p�，��保没有哪个基类实际上是另一个基�cȝ��z��c�R�?/span>

(58)在面向对象设计中如果你需要在包含关系和关联关�p�间作出选择�Q�请选择包含关系�?/span>

(59)不要把全局数据或全局函数用于�cȝ��对象的薄记工作。应当��用类变量或类�Ҏ��?/span>

(60)面向对象设计者不应当让物理设计准则来破坏他们的逻辑设计。但是，在对逻辑设计作出决策的过�E�中我们�l�常用到物理设计准则�?/span>

(61)不要�l�开公共接口��M��改对象的状态�?/span>

Snape 2012-04-01 07:41 发表评论

关于默认构造函数的几个错误认识�Q�四�U�情况下�Q�编译器会生成默认构造函敎ͼ�

Snape — Sat, 31 Mar 2012 22:19:00 GMT

假期间闲来无�?��׃��载了某大师的VC++视频资料。在讲到C++�?说是如果�E�序员没�?span style="color: red; ">自己定义默认构造函�?/span>,那么�~�译器会自动为我�?span style="color: red; ">产生一个默认的构造函�?/span>�?本来�q�个错误的认识很多程序员都有,不��为奇。但有这么多�q�编�E�经验的高手也有�q�样的错误认识就不禁让我哑然了�?/div>

其实�~�程语言和我们所用的��M��软�g没有区别,例如Photoshop、AutoCAD之类。其唯一不同的是我们用的�~�程语言是基于编译器�?而应用��Y件是��Z��我们的编�E�语�a�的�?/div>

既然我们所用的软�g是基于编译器�?那么理解�~�译器在背后到底为我们做了些什么、在什么情况下做了哪些事情��显得异帔R��要。这��像Photoshop会�ؓ你��生一些基本图形例如矩形、三角�Ş之类,而不会凭�I�Z�生一些风景优��的囄��一栗��?/div>

在《C++ Annotated Reference Manual(ARM)[ELLIS90]》中的Section 12.1告诉我们:"Default constructors...在需要的时候被�~�译器��生出�?�?/div>

其实默认构造函��C��是分��Z��cȝ��:有用的、无用的�?/div>

所�?span style="color: red; ">有用的标准也是就默认构造函��C��为我们的�c�d��一些初始化操作。那么无用的��׃��会做��M��工作,从而对我们的类也就没有��M��意义。所�?我们通常所说的默认构造函数是�?span style="color: red; ">有用的默认构造函�?其英文名字叫nontrivial default constructor�?/span>

那么到底什么时候编译器会�ؓ我们产生nontrivial default constructor�?有下面四中情�?

①如果一个类里面某个成员对象有nontrivial default constructor,�~�译器就会�ؓ我们的类产生nontrivial default constructor�?/span>

那么�~�译器这样做的理由是什�?

�{�案是因为类成员对象有nontrivial default constructor,那么�~�译器就需�?span style="color: red; ">昑ּ�的来调用�q�个�c�L��员对象的nontrivial default constructor。而编译器��x��式的调用�c�L��员对象的nontrivial default constructor,��需要自己来合成一些代码来调用。但是记�?�~�译器合成的nontrivial default constructor仅仅调用�c�L��员对象的默认构造函�?而不�Ҏ��们类里面的其它变量做��M��初始化操作�?/span>

也就是说,如果你想初始化类成员变量以外的变量例如一个int、一个String,那么�?span style="color: red; ">��自己定义默认构造函数来完成�q�些变量的初始化。而编译器会对你定义的默认构造函数做相应的扩�?从而调用类成员对象的nontrivial default constructor�?/div>

②如果一个派生类�?span style="color: red; ">基类�?/span>nontrivial default constructor,那么�~�译器会为派生类合成一个nontrivial default constructor�?/div>

�~�译器这��L��理由�?因�ؓ�z��c�被合成旉��要显式调用基�cȝ��默认构造函数�?/div>

③如何一个类里面隐式的含�?span style="color: red; ">��M��virtual function table(或vtbl)、pointer member(或vptr)�?/span>

�~�译器这样做的理由很��?因�ؓ�q�些vtbl或vptr需要编译器隐式(implicit)的合成出�?那么�~�译器就把合成动作放��C��默认构造函数里面。所以编译器必须自己产生一个默认构造函数来完成�q�些操作�?/div>

所以如果你的类里带有�Q�?span style="color: red; ">virtual function,那么�~�译器会��Z��合成一个默认构造函数�?/span>

④如果一�?span style="color: red; ">�c�虚�l�承于其它类�?/span>

�~�译器这样做的理由和③�c�M��:因�ؓ虚��扉K��要维护一个类似指针一�?可以动态的军_��内存地址的东�?不同�~�译器对虚��承的实现不仅相同)�?/div>

那么除了以上四种情况,�~�译器�ƈ不会为我们的�c�M�生默认构造函数�?/span>

所以编�E�中切忌惛_��?要明白哪些事情是�~�译器做�?哪些事情需要程序员来完成的。就像堆所占用的资源需要程序员自己来释�?而栈�I�间是编译器��理的一栗��?/div>

只有如此,才能�~�写��量更高的代码�?/div>

Snape 2012-04-01 06:19 发表评论

Snape — Sat, 31 Mar 2012 21:51:00 GMT

如何学好C++语言�Q��{�Q?/a>

原文地址�Q?a style="color: #0066ff; text-decoration: none; ">http://coolshell.cn/articles/4119.html

因�ؓ之前收藏的地址找不��C��Q�所以重新发一�?/p>

昨天写了一��?a title="如何学好C语言" target="_blank" style="color: #0066ff; text-decoration: none; ">如何学好C语言�Q�就有�h回复问我如何学好C++�Q�所以，我把我个人的一些学习经验写在这里，希望对大家有用。首先，因�ؓ如何学好C语言中谈��C��法和系�l�，所以这里就只谈C++语言�?/p>

C++是最隄��语言。这个世界上最隄��~�程语言可能非C++莫属了。你千万不要以�ؓ几天��可以学好C++�Q�C++的学习曲�U�是相当BT的，你可以看�?a title="C++ �E�序员自信心曲线�? target="_blank" style="color: #0066ff; text-decoration: none; ">�q�篇文章。C++是一门很自由的语�a��Q�自由到了有�?a title="恐怖的C++语言" target="_blank" style="color: #0066ff; text-decoration: none; ">BT和恐怖的地步。我甚至认�ؓC++�q�不是一门成熟的�~�程语言�Q�因为太�Ҏ��犯错了。所以，你一定要在一开始就要有很小心�}慎的态度�Q��ƈ把C++当成一�U�难以训服的猛兽来看�?/strong>�?/li>

多问“��Z��么要�q�样”的问�?/strong>。学习C++一定要多问几个“��Z��么是�q�样”�Q?#8220;凭什么要�q�样”的问题。比如：很多人知道C++有拷贝构造函数和初始化列表，但你真的知道��Z��么要有拷贝构造函敎ͼ��Z��么要有初始化列表吗？��Z��么要有template�Q��ؓ什么要有RTTI�Q��ؓ什么不是别的呢�Q�难道就是�ؓ了让一门语�a�变得Cool一些吗�Q�完全不是这��L��Q�C++中的��M��一个feature都有些实实在在的原因�Q?strong>你一定要��M��解�ؓ什么要把C++设计成这��L��原因�Q�你才能学好C++。有�I�看看�?a target="_blank" style="color: #0066ff; text-decoration: none; ">C++演化和设�?/a>》一书�?/li>

看书�Q�大量的C++�?/strong>。你可以按如下先后顺序阅读（下面�q�些书，我花了大�U?-5�q�的旉��Q�今天我�q�在随时温习�Q?ul style="list-style-type: disc; margin-left: 45px; ">
�?a target="_blank" style="color: #0066ff; text-decoration: none; ">C++ Primer》，�q�本初��L��可能让会你啃得很痛苦�Q�所有的语言的特性和��Z��么都在里面了�Q�好好读诅R��当然由C++之父写的�?a target="_blank" style="color: #0066ff; text-decoration: none; ">C++�E�序设计语言》也不错。两本看一本就好了�Q�我看的是前者）�?/li>
了解C++的语法仅仅是万里长征的第一步，你还需要看看�?a target="_blank" style="color: #0066ff; text-decoration: none; ">Effective C++》和�?a target="_blank" style="color: #0066ff; text-decoration: none; ">More Effective C++》这两本书�ƈ不厚�Q�但我从02�q�就一直看到现在，每次��L��都有新的体会�Q�这两本书太�l�典了。如果你对C语言不熟�Q�这两本书会让你回去补C语言的课�?/li>
Think in C++同样是另一本经�怹�极的书，学c++必读�Q�但是中文版的翻译的很不好，所以还是去读英文版的吧�?/li>
�?a target="_blank" style="color: #0066ff; text-decoration: none; ">C++沉思录》同样非常值得一读，�q�里教的不是�~�程�Q�而是思考的�Ҏ��Q�这是相当珍�늚��?/li>
�?a target="_blank" style="color: #0066ff; text-decoration: none; ">Exceptional C++》和�?a target="_blank" style="color: #0066ff; text-decoration: none; ">More Exceptional C++》让你看看各�U�问题的解决�Ҏ��和一些常见的�l�典错误�?/li>
�?a target="_blank" style="color: #0066ff; text-decoration: none; ">Advanced C++》和�?a target="_blank" style="color: #0066ff; text-decoration: none; ">Modern C++》可以让你知道C++各种��奇的用法�?/li>
�?a target="_blank" style="color: #0066ff; text-decoration: none; ">泛型�~�程与STL》是把C++实践��C��极致的东�ѝ��很强大。STL——��一��L��模板库（容器�Q�算法和函数对象�Q�，不得不服�?/li>
�?a target="_blank" style="color: #0066ff; text-decoration: none; ">深入探烦C++对象模型》让你了解编译器下的C++是什么样的，让你了解C++的性能�q�不差。这个对于C++的程序员太关键了。我以前写过的�?a target="_blank" style="color: #0066ff; text-decoration: none; ">C++虚函数表解析》还有�?a target="_blank" style="color: #0066ff; text-decoration: none; ">C++对象内存布局》属于这个范畴�?/li>

和Java语言做对�?/strong>。我个�h以�ؓJava对C++�q�个�q�不成熟的语�a�做了很多调整�Q�规范和限制。所以，�Ҏ��一下Java和C++�Q�想一惻I��Z��么一些东西在C++中可以做�Q�但在Java中却不行。比如：Java的异常是必需要catch的，不然��׃��~�译不通过。�ؓ什么Java不提供操作符重蝲�Q��ؓ什么Java会引入接口来做多重��承？��Z��么Java没有像C++那样的I/O字符��？��Z��么Java不支持指针？��Z��么Java可以做到垃圾回收�Q�等�{��?strong>Java体现着很多面向对象设计的东西，学习Java有助于你学会怎么更好��C��用C++来编�E?/strong>�?/li>

面向对象设计 。虽�?a title="面向对象是个骗局�Q�！" target="_blank" style="color: #0066ff; text-decoration: none; ">面向对象可能是个骗局。但是我觉得面向对象设计中的一些实践非常的不错�Q�比如，单一原则�Q�依赖倒置原则�Q�等�{�，都非常地�l�典。�?a target="_blank" style="color: #0066ff; text-decoration: none; ">设计模式》必需一读，�?a target="_blank" style="color: #0066ff; text-decoration: none; ">面向对象的分析和设计》可以一诅R�?strong>但不可以设计模式��Z��心来�~�程�Q�而应该是用设计模式来解藕�?/li>

�c�d��学习。看看MFC是怎么��装Windows API的，看看ACE是怎么面向对象的，看看boost是怎么玩面向对象的�Q�看看CPPUnit又是怎么设计的。当�Ӟ��Java的JDK中有太多的设计模�?/a>�Q�可以参考�?/li>

希望没有吓到大家�Q��ƈ�Ƣ迎大家补充�?/p>

—————更新 2011/03/30 19:20————

更新几个观点�Q?/p>

1�Q�我不擅长写书评�Q�所以推荐的�q�些书可能会让你有点看点没有感觉�Q�你可以上豆瓣或是China-pub上看看书评�?/li>
2�Q�C++有很多奇淫技巧，有的很BT�Q�包括虚函数表，也许会有��得有�Ҏ��意思，但我觉得很有意思，一斚w��可以了解一门语�a�的实现细节，另一斚w��可以开阔思�\。我从学习这些知识中受益很多�?/li>
3�Q�上�q�是我的个�h的学习历�E�，我觉得对我很有效�Q�所以是�l�验之谈�?/li>
4�Q�这�cȝ��文章在网上有很多很多�Q�我不是�W�一个写�q�样的文章，我也不是写得最好的�Q�我�q�不希望用长��大论来谈论什么。只是想�l�大家了解一下大概的学习样子。毕竟，C++博大�_�深�Q��Q何一��文章都无法说好。不如就��单一些�?/li>

Snape 2012-04-01 05:51 发表评论

一个类的实例化对象所占空间的大小

Snape — Sat, 31 Mar 2012 19:25:00 GMT
     摘要: 一个类的实例化对象所占空间的大小注意不要说类的大��?是类的对象的大小.首先�Q�类的大��是什么？��切的说�Q�类只是一个类型定义，它是没有大小可言的�?nbsp;用sizeof�q�算�W�对一个类型名操作�Q�得到的是具有该�c�d��实体的大��?nbsp;如果 Class A; A obj; 那么sizeof(A)==sizeof(obj) 那么sizeof(A)的大��和成员的大...  阅读全文

Snape 2012-04-01 03:25 发表评论

extern "C"

Snape — Sat, 31 Mar 2012 03:43:00 GMT

��?/h3>　　extern "C" 包含双重含义�Q�从字面上即可得刎ͼ�首先�Q�被它修饰的目标�?#8220;extern”的；其次�Q�被它修饰的目标�?#8220;C”的。让我们来详�l�解读这两重含义�?br />含义
　　�Q?�Q?被extern 限定�?/span>函数�?/span>变量是extern�c�d��的：
　　a. extern修饰变量的声明。�D例来��_��如果文�ga.c需要引用b.c中变量int v�Q�就可以在a.c中声明extern int v�Q�然后就可以引用变量v。这里需要注意的是，被引用的变量v的链接属性必��L��外链接（external�Q�的�Q�也��是说a.c要引用到v�Q�不只是取决于在a.c中声明extern int v�Q�还取决于变量v本��n是能够被引用到的。这涉及到c语言的另外一个话题－�Q�变量的作用域。能够被其他模块以extern修饰�W�引用到的变量通常是全局变量。还有很重要的一�Ҏ��Q�extern int v可以攑֜�a.c中的��M��地方�Q�比如你可以在a.c中的函数fun定义的开头处声明extern int v�Q�然后就可以引用到变量v了，只不�q�这样只能在函数fun作用域中引用v�|�了�Q�这�q�是变量作用域的问题。对于这一�Ҏ��_��很多��Z��用的时候都心存��虑。好像extern声明只能用于文�g作用域似的�?/span>
　　b. extern修饰函数声明。从本质上来�Ԍ��变量和函数没有区别。函数名是指向函��C��q�制块开头处的指针。如果文件a.c需要引用b.c中的函数�Q�比如在b.c中原型是int fun(int mu)�Q�那么就可以在a.c中声明extern int fun�Q�int mu�Q�，然后��p��使用fun来做��M��事情。就像变量的声明一��P��extern int fun�Q�int mu�Q�可以放在a.c中�Q何地方，而不一定非要放在a.c的文件作用域的范围中。对其他模块中函数的引用�Q�最常用的方法是包含�q�些函数声明的头文�g。��用extern和包含头文�g来引用函数有什么区别呢�Q�extern的引用方式比包含头文件要��z�得多！extern的��用方法是直接了当的，惛_��用哪个函数就用extern声明哪个函数。这大概是KISS原则的一�U�体现吧�Q�这样做的一个明昄��好处是，会加速程序的�~�译�Q�确切的说是预处理）的过�E�，节省旉��。在大型C�E�序�~�译�q�程中，�q�种差异是非常明昄��?/span>
　　�Q?�Q?被extern "C"修饰的变量和函数是按照C语言方式�~�译和连接的�Q?/span>
　　未加extern “C”声明时的�~�译方式�?/span>
　　首先看看C++中对�c�M��C的函数是怎样�~�译的�?/span>
　　作�ؓ一�U?/span>面向对象的语�a��Q�C++支持函数重蝲�Q�而过�E�式语言C则不支持。函数被C++�~�译后在�W�号库中的名字与C语言的不同。例如，假设某个函数的原型�ؓ�Q?/span>
　　voidfoo( int x, int y );
　　该函数被C�~�译器编译后在符号库中的名字为_foo�Q�而C++�~�译器则会��生像_foo_int_int之类的名�?/span>�Q�不同的�~�译器可能生成的名字不同�Q�但是都采用了相同的机制�Q�生成的新名字称�?#8220;mangled name”�Q�。_foo_int_int�q�样的名字包含了函数名、函数参数数量及�c�d��信息�Q�C++��是靠这�U�机制来实现函数重蝲的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )�~�译生成的符��h��不相同的�Q�后者�ؓ_foo_int_float�?/span>
　　同样圎ͼ�C++中的变量除支�?/span>局部变�?/a>外，�q�支持类成员变量和全局变量。用��h��~�写�E�序的类成员变量可能与全局变量同名�Q�我们以"."来区分。而本质上�Q�编译器在进行编译时�Q�与函数的处理相��|��也�ؓ�c�M��的变量取了一个独一无二的名字，�q�个名字与用��L��序中同名的全局变量名字不同�?/span>
　　未加extern "C"声明时的�q�接方式
　　假设在C++中，模块A的头文�g如下�Q?/span>
　　// 模块A头文件　moduleA.h
　　#ifndef MODULE_A_H
　　#define MODULE_A_H
　　int foo( int x, int y );
　　#endif
　　在模块B中引用该函数�Q?/span>
　　// 模块B实现文�g　moduleB.cpp
　　#i nclude "moduleA.h"
　　foo(2,3);
　　实际上，在连接阶�D�，�q�接器会从模块A生成的目标文件moduleA.obj中寻�?/span>_foo_int_int�q�样的符��P��
　　加extern "C"声明后的�~�译和连接方�?/span>
　　加extern "C"声明后，模块A的头文�g变�ؓ�Q?/span>
　　// 模块A头文件　moduleA.h
　　#ifndef MODULE_A_H
　　#define MODULE_A_H
　　extern "C" int foo( int x, int y );
　　#endif
　　在模块B的实现文件中仍然调用foo�Q?,3�Q�，其结果是�Q?/span>
　　�Q?�Q�模块A�~�译生成foo的目标代码时�Q�没有对其名字进行特�D�处理，采用了C语言的方式；
　　�Q?�Q�连接器在�ؓ模块B的目标代码寻找foo(2,3)调用�Ӟ��L��的是未经修改的符号名_foo�?/span>
　　如果在模块A中函数声明了foo为extern "C"�c�d��Q�而模块B中包含的是extern int foo( int x, int y ) �Q�则模块B找不到模块A中的函数�Q�反之亦然�?/span>
　　所以，可以用一句话概括extern “C”�q�个声明的真实目的（��M��语言中的��M��语法�Ҏ��的诞生都不是随意而�ؓ的，来源于真实世界的需求驱动。我们在思考问题时�Q�不能只停留在这个语�a�是怎么做的�Q�还要问一问它��Z��么要�q�么做，动机是什么，�q�样我们可以更深入地理解许多问题�Q�：
　　实现C++与C及其它语�a�的�؜合编�E��?/span>
　　明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的��用技巧�?/span>
extern "C"的惯用法
　　�Q?�Q?/span>在C++中引用C语言中的函数和变�?/span>�Q�在包含C语言头文�Ӟ��假设为cExample.h�Q�时�Q�需�q�行下列处理�Q?/span>
　　extern "C"
　　{
　　#i nclude "cExample.h"
　　}
　　而在C语言的头文�g中，对其外部函数只能指定为extern�c�d��Q�C语言中不支持extern "C"声明�Q�在.c文�g中包含了extern "C"时会出现�~�译语法错误�?/span>
　　�W�者编写的C++引用C函数例子工程中包含的三个文�g�?/span>源代�?/a>如下�Q?/span>
　　/* c语言头文�Ӟ��cExample.h */
　　#ifndef C_EXAMPLE_H
　　#define C_EXAMPLE_H
　　extern int add(int x,int y);
　　#endif
　　/* c语言实现文�g�Q�cExample.c */
　　#i nclude "cExample.h"
　　int add( int x, int y )
　　{
　　return x + y;
　　}
　　// c++实现文�g�Q�调用add�Q�cppFile.cpp
　　extern "C"
　　{
　　#i nclude "cExample.h"
　　}
　　int main(int argc, char* argv[])
　　{
　　add(2,3);
　　return 0;
　　}
　　�Q?/span>注意�q�里如果用GCC�~�译的时�?/span>�Q�请先��用gcc -c选项生成cExample.o�Q�再使用g++ -o cppFile cppFile.cpp cExample.o才能生成预期的c++调用c函数的结果，否则�Q��用g++ -o cppFile cppFile.cpp cExample.c�~�译器会报错�Q�而当cppFile.cpp 文�g中不使用下列语句
　　extern "C"
　　{
　　#i nclude "cExample.h"
　　}
　　而改�?/span>
　　#i nclude "cExample.h"
　　extern "C" int add( int x, int y );
　　�?/span>
　　g++ -o cppFile cppFile.cpp cExample.c的编译过�E�会把add函数按c++的方式解释�ؓ_foo_int_int�q�样的符受��?/span>
　　�Q?/span>
　　如果C++调用一个C语言�~�写�?DLL�Ӟ��当包�?DLL的头文�g或声明接口函数时�Q�应加extern "C" {　}�?/span>
　　�Q?�Q?/span>在C中引用C++语言中的函数和变量时�Q�C++的头文�g需��d��extern "C"�Q�但是在C语言中不能直接引用声明了extern "C"的该头文�Ӟ��应该仅将C文�g中将C++中定义的extern "C"函数声明为extern�c�d��?/span>
　　�W�者编写的C引用C++函数例子工程中包含的三个文�g的源代码如下�Q?/span>
　　//C++头文�?cppExample.h
　　#ifndef CPP_EXAMPLE_H
　　#define CPP_EXAMPLE_H
　　extern "C" int add( int x, int y );
　　#endif
　　//C++实现文�g cppExample.cpp
　　#i nclude "cppExample.h"
　　int add( int x, int y )
　　{
　　return x + y;
　　}
　　/* C实现文�g cFile.c
　　/* �q�样会编译出错：#i nclude "cppExample.h" */
　　extern int add( int x, int y );
　　int main( int argc, char* argv[] )
　　{
　　add( 2, 3 );
　　return 0;
　　}

Snape 2012-03-31 11:43 发表评论

C/C++. filename, line, onexit

Snape — Fri, 30 Mar 2012 18:11:00 GMT

如何判断一�D늨�序是由C �~�译�E�序�q�是由C++�~�译�E�序�~�译的？
�{�案�Q?nbsp;
view plain copy to clipboard print ?
#ifdef __cplusplus
cout<<"c++";
#else
cout<<"c";
#endif

如何打印出当前源文�g的文件名以及源文件的当前行号�Q?nbsp;
�{�案�Q?nbsp;
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__和__LINE__是系�l�预定义宏，�q�种宏�ƈ不是在某个文件中定义的，而是��q��译器定义的�?/p>
main ��d��数执行完毕后�Q�是否可能会再执行一�D�代码，�l�出说明�Q?nbsp;
�{�案�Q�可以，可以用_onexit 注册一个函敎ͼ�它会在main 之后执行�?/p>
view plain copy to clipboard print ?
#include
using namespace std;

int fn1()
{
    printf( "next.\n" );
    return 0;
}
int fn2()
{
    printf( "executed " );
    return 0;
}
int fn3()
{
    printf( "is " );
    return 0;
}
int fn4()
{
    printf( "This " );
    return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
    _onexit( fn1 );
    _onexit( fn2 );
    _onexit( fn3 );
    _onexit( fn4 );
    printf( "This is executed first.\n" );

    return 0;
}
输出�l�果为：
The _onexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to _onexit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to _onexit cannot take parameters.

�c�L��员函数的重蝲、覆盖和隐藏区别�Q?nbsp;
�{�案�Q?nbsp;
a.成员函数被重载的特征�Q?nbsp;
�Q?�Q�相同的范围�Q�在同一个类中）�Q?nbsp;
�Q?�Q�函数名字相同；
�Q?�Q�参��C��同；
�Q?�Q�virtual 关键字可有可无�?/p>
�Q?�Q�const的区�?nbsp;
b.覆盖是指�z��c�d��数覆盖基�c�d��敎ͼ�特征是：
�Q?�Q�不同的范围�Q�分别位于派生类与基�c�）�Q?nbsp;
�Q?�Q�函数名字相同；
�Q?�Q�参数相同；
�Q?�Q�基�c�d��数必��L��virtual 关键字�?nbsp;
c.“隐藏”是指�z��cȝ��函数屏蔽了与其同名的基类函数�Q�规则如下：
�Q?�Q�如果派生类的函��C��基类的函数同名，但是参数不同。此�Ӟ��不论有无virtual关键字，基类的函数将被隐藏（注意别与重蝲��h��Q��?nbsp;
�Q?�Q�如果派生类的函��C��基类的函数同名，�q�且参数也相同，但是基类函数没有virtual 关键字。此�Ӟ��基类的函数被隐藏�Q�注意别与覆盖�؜淆）

Snape 2012-03-31 02:11 发表评论

Snape — Tue, 27 Mar 2012 20:39:00 GMT
     摘要: ��拿�q�个囑ց�实验�?#include#include#include using namespace std; struct ArcNode{             //�?..  阅读全文

Snape 2012-03-28 04:39 发表评论

最大子序列、最长公共子丌Ӏ�最长公共子序列[转]

Snape — Tue, 27 Mar 2012 05:38:00 GMT
     摘要: 最大子序列最大子序列是要扑և�由数�l�成的一�l�数�l�中和最大的�q�箋子序列。比如{5,-3,4,2}的最大子序列��是 {5,-3,4,2}�Q�它的和�?,辑ֈ�最大；�?nbsp;{5,-6,4,2}的最大子序列是{4,2}�Q�它的和�?。你已经看出来了�Q�找最大子序列的方法很��单，只要前i��的和还没有��于0那么子序列就一直向后扩展，否则丢弃之前的子序列开始新的子序列�Q�同时我们要��C��各个子序列的和，最�?..  阅读全文

Snape 2012-03-27 13:38 发表评论

用C++设计一个不能被�l�承的类

Snape — Mon, 26 Mar 2012 00:33:00 GMT

题目�Q�用C++ 设计一个不能被�l�承的类�?/span>
分析�Q�这是Adobe 公司2007 �q�校园招聘的最新笔试题。这道题除了考察应聘者的C++ 基本功底外，�q�能考察反应能力�Q�是一道很好的题目�?/div>
在Java 中定义了关键字final �Q�被final 修饰的类不能被��ѝ��但在C++ 中没有final �q�个关键字，要实现这个要求还是需要花费一些精力�?/div>
首先惛_��的是在C++ 中，子类的构造函��C��自动调用父类的构造函数。同��P��子类的析构函��C��会自动调用父�cȝ��析构函数。要想一个类不能被��承，我们只要把它的构造函数和析构函数都定义�ؓ�U�有函数。那么当一个类试图从它那��承的时候，必然会由于试图调用构造函数、析构函数而导致编译错误�?/div>
可是�q�个�cȝ��构造函数和析构函数都是�U�有函数了，我们怎样才能得到该类的实例呢�Q�这难不倒我们，我们可以通过定义静态来创徏和释攄��的实例。基于这个思�\�Q�我们可以写出如下的代码�Q?/div>
///////////////////////////////////////////////////////////////////////
// Define a class which can't be derived from
///////////////////////////////////////////////////////////////////////
class FinalClass1
{
public :
      static FinalClass1* GetInstance()
      {
            return new FinalClass1;
      }

      static void DeleteInstance( FinalClass1* pInstance)
      {
            delete pInstance;
            pInstance = 0;
      }

private :
      FinalClass1() {}
      ~FinalClass1() {}
};
�q�个�c�L��不能被��承，但在总觉得它和一般的�c�L��些不一��P��使用��h��也有点不方便。比如，我们只能得到位于堆上的实例，而得不到位于栈上实例�?/div>
能不能实��C��个和一般类除了不能被��承之外其他用法都一��L��c�d��Q�办法��L��有的�Q�不�q�需要一些技巧。请看如下代码：
///////////////////////////////////////////////////////////////////////
// Define a class which can't be derived from
///////////////////////////////////////////////////////////////////////
template <typename T> class MakeFinal
{
      friend T;

private :
      MakeFinal() {}
      ~MakeFinal() {}
};

class FinalClass2 : virtual public MakeFinal<FinalClass2>
{
public :
      FinalClass2() {}
      ~FinalClass2() {}
};
�q�个�c�M��用�v来和一般的�c�L��有区别，可以在栈上、也可以在堆上创建实例。尽��类 MakeFinal <FinalClass2> 的构造函数和析构函数都是�U�有的，但由于类 FinalClass2 是它的友元函敎ͼ�因此�?span style="font-size: 10pt; color: #010001; line-height: 16px; "> FinalClass2 中调�?/span> MakeFinal <FinalClass2> 的构造函数和析构函数都不会造成�~�译错误�?/div>
但当我们试图�?span style="font-size: 10pt; color: #010001; line-height: 16px; "> FinalClass2 �l�承一个类�q�创建它的实例时�Q�却不同通过�~�译�?/div>
class Try : public FinalClass2
{
public :
      Try() {}
      ~Try() {}
};

Try temp;
�׃��c?span style="font-size: 10pt; color: #010001; line-height: 16px; "> FinalClass2 是从�c?span style="font-size: 10pt; color: #010001; line-height: 16px; "> MakeFinal <FinalClass2> 虚��承过来的�Q�在调用 Try 的构造函数的时候，会直接蟩�q?span style="font-size: 10pt; color: #010001; line-height: 16px; "> FinalClass2 而直接调�?span style="font-size: 10pt; color: #010001; line-height: 16px; "> MakeFinal<FinalClass2> 的构造函数。非帔R��憄��是， Try 不是 MakeFinal <FinalClass2> 的友元，因此不能调用其私有的构造函数�?/div>
��Z��上面的分析，试图�?span style="font-size: 10pt; color: #010001; "> FinalClass2 �l�承的类�Q�一旦实例化�Q�都会导致编译错误，因此�?span style="font-size: 10pt; color: #010001; "> FinalClass2 不能被��ѝ��这��满��了我们设计要求�?/div>

Snape 2012-03-26 08:33 发表评论

C语言二维数组动态分配和释放 [转]

Snape — Sun, 25 Mar 2012 23:49:00 GMT

C 二维数组动态分配和释放
(1)已知�W�二�l?/div>
Code-1
char (*a)[N];//指向数组的指�?/span>
a = (char (*)[N])malloc(sizeof(char *) * m);
printf("%d\n", sizeof(a));//4�Q�指�?/span>
printf("%d\n", sizeof(a[0]));//N�Q�一�l�数�l?/span>
free(a);
(2)已知�W�一�l?/div>
Code-2
char* a[M];//指针的数�l?/span>
int i;
for(i=0; i
a[i] = (char *)malloc(sizeof(char) * n);
printf("%d\n", sizeof(a));//4*M�Q�指针数�l?/span>
printf("%d\n", sizeof(a[0]));//4�Q�指�?/span>
for(i=0; i
   free(a[i]);
(3)已知�W�一�l�_��一�ơ分配内�?保证内存的连�l��?
Code-3
char* a[M];//指针的数�l?/span>
int i;
a[0] = (char *)malloc(sizeof(char) * M * n);
for(i=1; i
a[i] = a[i-1] + n;
printf("%d\n", sizeof(a));//4*M�Q�指针数�l?/span>
printf("%d\n", sizeof(a[0]));//4�Q�指�?/span>
free(a[0]);
(4)两维都未�?/div>
Code-4
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);//分配指针数组
for(i=0; i
{
a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数�l?/span>
}
printf("%d\n", sizeof(a));//4�Q�指�?/span>
printf("%d\n", sizeof(a[0]));//4�Q�指�?/span>
for(i=0; i
{
free(a[i]);
}
free(a);
(5)两维都未知，一�ơ分配内�?保证内存的连�l��?
Code-5
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m);//分配指针数组
a[0] = (char *)malloc(sizeof(char) * m * n);//一�ơ性分配所有空�?/span>
for(i=1; i
{
a[i] = a[i-1] + n;
}
printf("%d\n", sizeof(a));//4�Q�指�?/span>
printf("%d\n", sizeof(a[0]));//4�Q�指�?/span>
free(a[0]);
free(a);
2.C++动态分配二�l�数�l?/strong>
(1)已知�W�二�l?/div>
Code-6
char (*a)[N];//指向数组的指�?/span>
a = new char[m][N];
printf("%d\n", sizeof(a));//4�Q�指�?/span>
printf("%d\n", sizeof(a[0]));//N�Q�一�l�数�l?/span>
delete[] a;
(2)已知�W�一�l?/div>
Code-7
char* a[M];//指针的数�l?/span>
for(int i=0; i
   a[i] = new char[n];
printf("%d\n", sizeof(a));//4*M�Q�指针数�l?/span>
printf("%d\n", sizeof(a[0]));//4�Q�指�?/span>
for(i=0; i
   delete[] a[i];
(3)已知�W�一�l�_��一�ơ分配内�?保证内存的连�l��?
Code-8
char* a[M];//指针的数�l?/span>
a[0] = new char[M*n];
for(int i=1; i
a[i] = a[i-1] + n;
printf("%d\n", sizeof(a));//4*M�Q�指针数�l?/span>
printf("%d\n", sizeof(a[0]));//4�Q�指�?/span>
delete[] a[0];
(4)两维都未�?/div>
Code-9
char **a;
a = new char* [m];//分配指针数组
for(int i=0; i
{
a[i] = new char[n];//分配每个指针所指向的数�l?/span>
}
printf("%d\n", sizeof(a));//4�Q�指�?/span>
printf("%d\n", sizeof(a[0]));//4�Q�指�?/span>
for(i=0; i
delete[] a[i];
delete[] a;
(5)两维都未知，一�ơ分配内�?保证内存的连�l��?
Code-10
char **a;
a = new char* [m];
a[0] = new char[m * n];//一�ơ性分配所有空�?/span>
for(int i=1; i
{
a[i] = a[i-1] + n;//分配每个指针所指向的数�l?/span>
}
printf("%d\n", sizeof(a));//4�Q�指�?/span>
printf("%d\n", sizeof(a[0]));//4�Q�指�?/span>
delete[] a[0];
delete[] a;
多说一句：new和delete要注意配对��用，��x��多少个new��有多少个delete�Q�这��h��可以避免内存泄漏�Q?/span>
3.静态二�l�数�l�作为函数参��C��?/strong>
如果采用上述几种�Ҏ��动态分配二�l�数�l�，那么��对应的数据�c�d��作�ؓ函数参数��可以了。这里讨论静态二�l�数�l�作为函数参��C��递，��x��照以下的调用方式�Q?/div>
int a[2][3];
func(a);
C语言中将静态二�l�数�l�作为参��C��递比较麻烦，一般需要指明第二维的长度，如果不给定第二维长度�Q�则只能先将其作��Z��l�指针传递，然后利用二维数组的线性存储特性，在函��C��内�{化�ؓ�Ҏ��定元素的讉K��?/div>
首先写好��试代码�Q�以验证参数传递的正确性：
(1)�l�定�W�二�l�长�?/div>
Code-11
void func(int a[][N])
{
printf("%d\n", a[1][2]);
}
(2)不给定第二维长度
Code-12
void func(int* a)
{
printf("%d\n", a[1 * N + 2]);//计算元素位置
}
注意�Q��用该函数旉��要将二维数组首地址强制转换��Z��l�指针，即func((int*)a);

Snape 2012-03-26 07:49 发表评论

国产婷婷色一区二区三区在线,国产精品视频男人的天堂,亚洲综合电影

深入理解C语言(转coolshell)

�E�序员的奋斗�Ԍ��一�Q�——浅谈几�U�主要编�E�语�a�(�?

�E�序员的奋斗�Ԍ��一�Q?#8212;—���谈几种主要�~�程语言

字符串相似度���法介绍(整理)(�?

【�{】面向对象设计中的经验原�?/a>

关于默认构造函数的几个错误认识�Q�四�U�情况下�Q�编译器会生成默认构造函敎ͼ�

如何学好C++语言�Q��{�Q?/a>

一个类的实例化对象所占空间的大小

extern "C"

extern "C"的惯用法

C/C++. filename, line, onexit

最大子序列、最长公共子丌Ӏ�最长公共子序列[转]

用C++设计一个不能被�l�承的类

题目�Q�用C++ 设计一个不能被�l�承的类�?/span>

C语言 二维数组动态分配和释放 [转]

�E�序员的奋斗�Ԍ��一�Q?#8212;—��谈几种主要�~�程语言

字符串相似度��法介绍(整理)(�?

C语言二维数组动态分配和释放 [转]