c++部分知识小结&static和const的解释

关于二叉树

转载于http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/27/2659163.html

二叉树作为树的一种，是一种重要的数据结构，也是面试官经常考的东西。昨天看了一下关于树中的面试题，发现二叉树中的面试题比较常见的题型大概有下面几个：创建一颗二叉树（先序，中序，后序）、遍历一颗二叉树（先序，中序，后序和层次遍历）、求二叉树中叶子节点的个数、求二叉树的高度、求二叉树中两个节点的最近公共祖先、打印和为某一值的全部路径、求某一节点是否在一个树中等等。
几种常见的二叉树：
完全二叉树：若二叉树的高度是h，除第h层之外，其他（1~h-1）层的节点数都达到了最大个数，并且第h层的节点都连续的集中在最左边。想到点什么没？实际上，完全二叉树和堆联系比较紧密哈~~~

满二叉树：除最后一层外，每一层上的所有节点都有两个子节点，最后一层都是叶子节点。

哈夫曼树：又称为最有数，这是一种带权路径长度最短的树。哈夫曼编码就是哈夫曼树的应用。

平衡二叉树：所谓平衡二叉树指的是，左右两个子树的高度差的绝对值不超过 1。

红黑树：红黑树是每个节点都带颜色的树，节点颜色或是红色或是黑色，红黑树是一种查找树。红黑树有一个重要的性质，从根节点到叶子节点的最长的路径不多于最短的路径的长度的两倍。对于红黑树，插入，删除，查找的复杂度都是O（log N）。

string::npos的一些说明

转载自http://blog.youkuaiyun.com/devil_pull/article/details/25478525

一、定义
std::string::npos的定义：

static const size_t npos = -1;  

表示size_t的最大值（Maximum value for size_t），如果对 -1表示size_t的最大值有疑问可以采用如下代码验证：

#include <iostream>  
#include <limits>  
#include <string>  
using namespace std;  

int main()  
{  
    size_t npos = -1;  
    cout << "npos: " << npos << endl;  
    cout << "size_t max: " << numeric_limits<size_t>::max() << endl;  
}  

执行结果为：

             npos:           4294967295

             size_t max:  4294967295

可见他们是相等的，也就是说npos表示size_t的最大值

二、使用

2.1 如果作为一个返回值（return value）表示没有找到匹配项，例如：

#include <iostream>  
#include <limits>  
#include <string>  
using namespace std;  

int main()  
{  
    string filename = "test";  
    cout << "filename : " << filename << endl;  

    size_t idx = filename.find('.');   //作为return value，表示没有匹配项  
    if(idx == string::npos)      
    {  
        cout << "filename does not contain any period!" << endl;  
    }  
}  

2.2 但是string::npos作为string的成员函数的一个长度参数时，表示“直到字符串结束（until the end of the string）”。例如：

tmpname.replace(idx+1, string::npos, suffix);  

这里的string::npos就是一个长度参数，表示直到字符串的结束，配合idx+1表示，string的剩余部分。

#include <iostream>  
#include <limits>  
#include <string>  
using namespace std;  

int main()  
{  
    string filename = "test.cpp";  
    cout << "filename : " << filename << endl;  

    size_t idx = filename.find('.');   //as a return value  
    if(idx == string::npos)      
    {  
        cout << "filename does not contain any period!" << endl;  
    }  
    else  
    {  
        string tmpname = filename;  
        tmpname.replace(idx + 1, string::npos, "xxx"); //string::npos作为长度参数，表示直到字符串结束  
        cout << "repalce: " << tmpname << endl;  
    }  
}  

执行结果为：

filename:test.cpp

replace: test.xxx

For Example:

#include<iostream>
#include<string>
using namespace std;
int main() {
  int n;
  string a,b;
  cin >> n;
  while (n--) {
      cin >> a >> b;
      if (a.find(b) != string::npos) {
          cout << "yes" << endl;
      } else {
          cout << "no" << endl;
      }
  }
  return 0;
}

RUN Result:

2
xcfdsa sa
yes
bgds ed
no

In this example ,we should learn how to use thefind()in the string template.

const的有关用法

在类成员函数的声明和定义中，
const的函数不能对其数据成员进行修改操作。
const的对象，不能引用非const的成员函数。

函数声明后面的const用法
void function() const{}

#include "stdafx.h"
#include <iostream>
using namespace std;

class aa{
    int num;
public:
    aa(){
        int b =10;
        num = b;
    };
    void out1(){
        cout<<num<<endl;
    }
    void out2() const{
        cout<<num<<endl;
    }
    void out3() const{
        num+=10; //出错，const函数不能修改其数据成员
        cout<<num<<endl;
    }

};
int _tmain(int argc, _TCHAR* argv[])
{
    aa a1;
    a1.out1();
    a1.out2();
    a1.out3();
    const aa a2;
    a2.out1(); // 错误，const的成员 不能访问非const的函数
    a2.out2();
    a2.out3();
    return 0;
}

static和const的解释

（来自一位佚名的大神^_^）

static 是c++中很常用的修饰符

它被用来控制变量的存储方式和可见性，下面从 static 修饰符的产生原因、作用谈起，全面分析static 修饰符的实质。

static 的两大作用:

一、控制存储方式：

static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间。

1、引出原因：函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，大家知道，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？
最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。

2、 解决方案：因此c++ 中引入了static，用它来修饰变量，它能够指示编译器将此变量在程序的静态存储区分配空间保存，这样即实现了目的，又使得此变量的存取范围不变。

二、控制可见性与连接类型 :

static还有一个作用，它会把变量的可见范围限制在编译单元中，使它成为一个内部连接，这时，它的反义词为”extern”.

static作用分析总结：static总是使得变量或对象的存储形式变成静态存储，连接方式变成内部连接，对于局部变量（已经是内部连接了），它仅改变其存储方式；对于全局变量（已经是静态存储了），它仅改变其连接类型。

类中的static成员：

一、出现原因及作用：

1、需要在一个类的各个对象间交互，即需要一个数据对象为整个类而非某个对象服务。

2、同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。

类的static成员满足了上述的要求，因为它具有如下特征：有独立的存储区，属于整个类。

二、注意：

1、对于静态的数据成员，连接器会保证它拥有一个单一的外部定义。静态数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。

2、类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致了它仅能访问类的静态数据和静态成员函数。

const 是c++中常用的类型修饰符

溯其本源，究其实质，希望能对大家理解const有所帮助，根据思维的承接关系，分为如 下几个部分进行阐述。

c++中为什么会引入const

c++的提出者当初是基于什么样的目的引入（或者说保留）const关键字呢？，这是一个有趣又有益的话题，对理解const很有帮助。

1． 大家知道，c++有一个类型严格的编译系统，这使得c++程序的错误在编译阶段即可发现许多，从而使得出错率大为减少，因此，也成为了c++与c相比，有着突出优点的一个方面。

2． c中很常见的预处理指令#define variablename variablevalue 可以很方便地进行值替代，这种值替代至少在三个方面优点突出：

一是避免了意义模糊的数字出现，使得程序语义流畅清晰，如下例：
#define user_num_max 107 这样就避免了直接使用107带来的困惑。

二是可以很方便地进行参数的调整与修改，如上例，当人数由107变为201时，进改动此处即可，

三是提高了程序的执行效率，由于使用了预编译器进行值替代，并不需要为这些常量分配存储空间，所以执行的效率较高。

鉴于以上的优点，这种预定义指令的使用在程序中随处可见。

3． 说到这里，大家可能会迷惑上述的1点、2点与const有什么关系呢?,好，请接着向下

看来：

预处理语句虽然有以上的许多优点，但它有个比较致命的缺点，即，预处理语句仅仅只是简单值替代，缺乏类型的检测机制。这样预处理语句就不能享受c++严格类型检查的好处，从而可能成为引发一系列错误的隐患。

4．好了，第一阶段结论出来了：
结论： const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

现在它的形式变成了：

const datatype variablename = variablevalue ;

为什么const能很好地取代预定义语句？
const 到底有什么大神通，使它可以振臂一挥取代预定义语句呢？

1． 首先，以const 修饰的常量值，具有不可变性，这是它能取代预定义语句的基础。

2． 第二，很明显，它也同样可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。

3． 第三，c++的编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作， 使得它的效率也很高，同时，这也是它取代预定义语句的重要基础。这里，我要提一下，为什么说这一点是也是它能取代预定义语句的基础，这是因为，编译器不会 去读存储的内容，如果编译器为const分配了存储空间，它就不能够成为一个编译期间的常量了。

4． 最后，const定义也像一个普通的变量定义一样，它会由编译器对它进行类型的检测，消除了预定义语句的隐患。

const 使用情况分类详析

1.const 用于指针的两种情况分析：

int const *a; 　file://a可变，*a不可变
int *const a; 　file://a不可变，*a可变 ```

分析：const 是一个左结合的类型修饰符，它与其左侧的类型修饰符和为一个类型修饰符，所以，int const 限定 *a,不限定a。int *const 限定a,不限定*a。

2.const 限定函数的传递值参数：

void fun(const int var);

分析：上述写法限定参数在函数体中不可被改变。由值传递的特点可知，var在函数体中的改变不会影响到函数外部。所以，此限定与函数的使用者无关，仅与函数的编写者有关。
结论：最好在函数的内部进行限定，对外部调用者屏蔽，以免引起困惑。如可改写如下：

void fun(int var){
const int & varalias = var;

varalias ....

.....

} 

3.const 限定函数的值型返回值：

const int fun1(); 

const myclass fun2();

分析:上述写法限定函数的返回值不可被更新，当函数返回内部的类型时（如fun1），已经是一个数值，当然不可被赋值更新，所以，此时const无意 义，最好去掉，以免困惑。当函数返回自定义的类型时（如fun2），这个类型仍然包含可以被赋值的变量成员，所以，此时有意义。

1. 传递与返回地址： 此种情况最为常见，由地址变量的特点可知，适当使用const，意义昭然。

5.　const 限定类的成员函数：

class classname {

public:

int fun() const;

.....

}

注意：采用此种const 后置的形式是一种规定，亦为了不引起混淆。在此函数的声明中和定义中均要使用const,因为const已经成为类型信息的一部分。

获得能力：可以操作常量对象。

失去能力：不能修改类的数据成员，不能在函数中调用其他不是const的函数。

小小的补充：

1、const类型
const类型的对象的所有数据成员的值不能被修改。
const类型的数据成员必须使用初始化器进行初始化，任何其他函数都不能对其赋值，且其值不能被修改。
const类型的成员函数只能引用本类中的数据成员，而不能修改它们。例：

class Circle{
public:
    Circle(double r=0):PI(3.14){radius=r;} 
      //用初始化器初始化const数据成员
    double getPI(){ return PI;}
      //const数据成员可以被访问 
    void setPI(double p){PI=p;}  
      //非法,不能修改const成员的值
    const double getR(){ return radius;}
      //const成员函数可以访问数据成员 
   double setR(double r)const{radius=r;}
      //非法，const成员函数不能修改数据成员 
private:
    const double PI ;
    double radius; 
};

2、static类型
类中static类型成员独立于对象而存在，由所有对象共享。static类型的数据成员只能在类里面定义，且在类中只能被static类型的成员函数访问,在主函数中可以被类的对象或类访问。例：

class Circle{
public:
static double getPI();
private:
static double PI ;
};
double Circle::PI=3.14159;
double Circle::getPI(){ return PI;}

int main(){
    Circle a;
    cout<<a.getPI()<<endl;
         cout<<Circle::getPI()<<endl;
//友情提示：若题目中出现用对象访问数据成员或 
//成员函数，可断定该成员为static类型。
    return 0;
}