sinat_29844779的博客

栈：栈中分配局部变量空间，是系统自动分配内存空间的，当我们在函数中定义一个变量的时候，系统自动在栈上为其开辟空间。由于栈上的空间是自动分配自动回收的，所以栈上的数据的生存周期只是在函数的运行过程中，运行后就释放掉，不可以再访问。堆：堆区分配程序员申请的内存空间，堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是如果程序员不主动去释放空间会造成内存泄漏。静态区：分配静态变量，全局变

extern 可以置于函数或者变量前。第一、当它与“C”一起使用时，如：extern “C” void fun(int a,int b),则告诉编译器在编译fun这个函数名时按照C的规则去翻译相应的函数名而不是C++的，C++的规则在翻译这个函数名时会把fun这个函数名面目全非。第二，当extern不与"C"在一起修饰变量或函数时，如在头文件中: extern int g_Int; 它的作用就是声

顶层const：    顶层const表示指针本身是个常量，而用底层const表示指针所指的对象是个常量。  将*放在const关键字之前用以说明指针是一个常量，即不变的是指针本身的值而非指向的那个值。int i = 0;int *const p1 = &i;//不能改变p1的值，这是一个顶层constconst int c1 = 42;//不能改变c1的值，这个是一个顶层const

定义类的静态数据成员：既可以在类的内部也可以在类的外部定义静态成员函数。当在类的外部定义静态数据成员时，不能重复static关键字，该关键字只出现在类的内部的声明语句中。静态数据成员不属于类的任何一个对象，所以它们并不是在创建类的对象时被定义的，这意味着它们不是由类的构造函数初始化的。一般来说不能在类的内部来初始化静态数据成员。必须在类的外部定义和初始化每个静态数据成员，一个静态数据成员只能定

内联函数的定义：内联函数可以避免函数调用时的开销，内联函数是将函数返回值的类型前面加上inline关键字，这样就可以声明一个内联函数。优点：调用函数一般比求等价表达式的值要慢一些。一次函数调用其实包含着一系列工作：调用前要先保存寄存器，并在返回时恢复；可能需要拷贝实参；程序转向一个新的位置继续执行。内联函数可避免函数调用时的开销，将函数指定为内联函数，通常就是将它在每个调用点上“内联地”展

一、static_cast：任何具有明确定义的类型转换，只要不包含底层const，都可以使用static_cast。double slope = static_cast(j)/i;static_cast对于编译器无法自动执行的类型转换也是非常有用的。例如使用static_cast找回存在于void*指针中的值。void* p= &d;//正确，任何非常量对象的地址都能存入void*do

一：定义和性质的区别：1、指针是一个变量，它是一个明确的对象，只不过这个变量存储的是一个地址，，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个对象，只不过是原变量的一个别名而已。2.可以有const指针，但是没有const引用；3、指针可以有多级，但是引用只能是一级；4、指针的值可以为空，但是引用的值不能为NULL;5、指针的值在初始化后可以改变，即指向其它的存储单元

1、new操作符从自由存储区上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是c++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，c语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。自由存储区是否可以是堆？这取决于operate

堆是操作系统所维护的一块特殊内存，它提供了动态分配的功能，当运行程序调用malloc()时就会从中分配，稍后调用free可把内存交还。而自由存储是C++中通过new和delete动态分配和释放对象的抽象概念，通过new来申请的内存区域可称为自由存储区。基本上，所有的C++编译器默认使用堆来实现自由存储，也即是缺省的全局运算符new和delete也许会按照malloc和free的方式来被实现，这时藉

int divide(int dividend, int divisor) { if (!divisor || (dividend == INT_MIN && divisor == -1)) return INT_MAX; int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;

string addBinary(string a, string b) { string s = ""; int c = 0, i = a.size() - 1, j = b.size() - 1; while(i >= 0 || j >= 0 || c == 1) { c += i

void QSort(int *num,int low,int high){ int pivot; if(low<high) { pivot=Partition(num,low,high); QSort(num,low,pivot-1); QSort(num,pivot+1,high); }}int Partition(int *num,int low,int

/*四种I/O模型：一、阻塞I/O：阻塞I/O执行的系统调用可能因为无法立即完成而被操作系统挂起直到等到的事件发生为止；二、I/O复用是指：应用程序通过I/O复用函数向内核注册一组事件，内核通过I/O复用函数把其中就绪的事件通知给应用程序I/O复用函数本身是阻塞的，它们能提高程序效率的原因在于它们具有同时监听多个I/O事件的能力；三、SIGIO（信号驱动I/O），将一个目标文件描述符指

#include using namespace std;template class SmartPointer{public: SmartPointer(T *p=0):poin(p),use(new size_t(1)){} SmartPointer(const SmartPointer &p){ if(this!=&p) { poin = p.poin; us

#include #include using namespace std;class String{public: String(const char *data=NULL); String(const String &other); String& operator=(const String &other); void Print(); ~String();private

#include #define MAX 26using namespace std;struct Node{ bool isStr; Node *next[MAX];};void insert(Node *root,const char *s){ if(root==NULL||s=='\0') return; size_t i; Node *p = root; whi

这个问题有两种的思路，第一种是将整个的数组建堆，（时间复杂度是O(N)）,再分K次从堆的顶端取值，取完值之后将堆尾的元素放到堆首来下虑（K*logN）,总的时间复杂度是（O(N+K*logN)）.//对原始的数据原地建最大堆，时间为O(N),然后提取K次，每次提取时，取第一个值再下沉，k*logN,总的时间复杂度是O(N+k*logN)#define LENGTH 9#define GET

C++的多态性分为静态多态和动态多态。静态多态指的是在程序编译期决定调用哪个函数的行为是静态多态。比如：函数重载来实现！动态多态指的是在运行期决定调用哪个类型对象的函数。比如：虚函数来实现多态性。实现形式：声明一个基类的指针，利用该指针指向任意一个子类的对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。当用子类的指针指向一个强制转化为子类地址的基类对象，那么在指向成员函

typedef char *String_t定义了一个新的类型别名，有类型检查。而#define String_d char* 只是做了个简单的替换，无类型检查，前者在编译的时候处理，后者在预编译的时候处理。同时定义多个多个变量的时候有区别，主要的区别在于这种使用方式String_t a,b;String_d c,d;a ,b,c都是char* 类型，而d为char类型，由于typedef还要做类

虚函数是通过一张虚函数表来实现的。这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其内容真实反映实际的函数。在有虚函数的类的实例中这个表被分配在了这个实例的内存中，因此，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得很重要，它就像一个地图一样，指明了实际所应该调用的函数。c++编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函

静态内存：用来保存局部static对象、类static数据成员以及定义在任何杉树之外的变量。栈内存:用来保存定义在函数内的非static对象。分配在静态或栈内存中的对象由编辑器自动创建和销毁。对于栈对象，仅在其定义的程序块运行时才存在，static对象在使用之前分配，在程序结束时销毁。内存池：称作自由空间或堆，程序用堆来存储动态内存分配的对象，即那些在程序运行时分配的对象。动态对象的生

int*  p = new int[10];delete []p;数组中的元素按逆序销毁，即最后一个元素首先被销毁，然后是倒数第二个。当我们释放一个指向数组的指针时，空方括号是必须的，它指示编译器此指针指向一个对象数组的第一个元素。typedef int arrT[42];int *p = new arrT;delete []p;此处方括号是必须的，不管外表如何，p指向

1、编译器分两步处理类：首先编译成员的声明，然后才轮到成员函数体。因此，成员函数体可以随意使用类中的其他成员而无须在意这些成员出现的次序。2、C++  IO对象属于不能被拷贝的类型，当我们在实际中需要在函数中使用的时候，只能通过引用来传递他们。IO类型的三个独立的头文件是：iostream、fstream 、 sstream3、构造函数，任务：初始化类对象的数据成员，无论何时只要类的对象被

析构函数：在构造函数中，成员的初始化是在函数体执行之前完成的，且按照它们在类中出现的顺序进行初始化，在一个析构函数中，首先执行函数体，然后销毁成员，成员按照初始化的逆序销毁。析构函数释放对象在生存期分配的所有的资源。与普通指针不同，智能指针是类类型，所以具有析构函数，智能指针在析构阶段会被自动销毁。

int main(){  char str1[] = "hello world";  char str2[] = "hello world";  char* str3[] = "hello world";  char* str4[] = "hello world";   if(str1 == str2)       printf("str1and str2 ar

一、计算一个数字的二进制中的1的个数int   NumberOfOne(int n){   int count  = 0;   while(n){   ++count;  n = n&(n-1);}return count;}总结分析：把一个整数减去一，再和原整数做与运算，会把最右边的一个1变成0，那么一个整数而二进制表示中有多少个1就可以进行多少次这样

关于字符串的全排列的算法其中IsSwap()是用来剔除会导致重复的排列的情况的！void Permutation(char* pStr){ if(pStr==NULL) return; PermutationCore(pStr,pStr);}bool IsSwap(char* Begin,char*End ){ while(Begin!=End) { if(*Begin==

输入一条字符串，将其中的单词顺序逆转void reverseWords1(string &s) { reverse(s.begin(), s.end()); int storeIndex = 0; for (int i = 0; i < s.size(); i++) { if (s[i] != ' ') { if (sto

我们知道vector的增长方式，但是即使用erase函数，并不能将其空间进行回收，找到一种办法来回收vector的空间。vector t; for(int i = 0;i<50;i++) { t.push_back(i); cout<<"i="<<i<<"; size="<<t.capacity()<<endl; } for(int i = 49;i>=0;i--)

自己想找找归并排序怎么实现的，结果在网上居然没找到一个能用的归并排序的算法，经过自己的琢磨，现在写出了下面的算法。void MergeArray(int *a,int first,int middle,int last){ int n1 = middle-first; int n2 = last - middle-1;//注意此处的长度 int *L = new int[n1+1];

直接插入排序算法的时间复杂度为o(n*n)void InsertSort(int *a,int Length){ int i,j; for(i =1;i<Length;i++) { if(a[i]<a[i-1]) { int temp = a[i]; for(j = i-1;j>=0&&temp>a[j];j--) a[j+1] = a[j]; a[j

关于mapreduce的解释：把一堆杂乱无章的数据按照某种特征归纳起来，然后处理并得到最后的结果。Map面对的是杂乱无章的互不相关的数据，它解析每个数据，从中提取出key和value，也就是提取了数据的特征。经过MapReduce的Shuffle阶段之后，在Reduce阶段看到的都是已经归纳好的数据了，在此基础上我们可以做进一步的处理以便得到结果。这就回到了最初，终于知道MapReduce为何

算法题：把数组排成最小的数，输入一个正整数数组，把数组里所有的数字拼接起来排成一个数，打印拼接出来的所有的数字中的最小的一个。例如输入数组{3，,32，,321}，则打印出这3个数字能排成的最小数字是321323；const int MaxNumberLength = 10;char *StrCombine1 = new char[MaxNumberLength*2+1];char *StrC

基类中的受保护的成员对于派生类的成员和友元来说是可访问的；派生类的成员或友元只能通过派生类对象来访问基类的受保护成员，派生类对于一个基类对象中的受保护成员没有任何访问特权。

转载地址为：http://blog.csdn.net/u013074465/article/details/42780825一个空的类的大小为1个字节；1.类的大小为类的非静态成员数据的类型大小之和，也就是说静态成员数据不作考虑。c++将类的非静态数据成员存放在类的每个对象中，对于继承而来的非静态数据成员（不管基类是否为虚）都是如此；静态数据成员不是类的组成部分，它存放在程序的全局

背包问题仍然是一个最优解的问题，但是不能用贪心算法来求解。只能用动态规划方法来求解。#include int max(int a,int b){ return a<b?b:a;}int main(){ unsigned int weight[5]={0,1,3,5,9}; unsigned int value[5] ={0,2,3,4,7}; int vec = 10; i