小博客

在编写代码工程时，很多时候我们需要对象的唯一性，即整个工程或项目中只需要类的一个实例。可以通过设计模式的单例模式来实现。以下是我用c++实现的两种方式：第二种较第一种代码逻辑稍简单些。class Singlton{private: int m_nNum; static Singlton* m_pSinglton; Singlton(int num) { m_n

1、空类的sizeof是1。空类是指没有成员的类，类中的函数不占空间，除非是虚函数。如： class A        {             public:                      A(){}                     ~A(){}                     void fun(){}         };sizeo

下面代码列举了普通字符串匹配算法和KMP算法。KMP算法原理见算法导论第32章。代码中有简单的注释可以帮助理解：#include#includeusing namespace std;#define MAX 10000//KMP算法时间复杂度为O(n+m)，其中n为str的长度，m为pat的长度void kmp(string str,string pat){ boo

先看一段代码输出的结果：#includeusing namespace std;class A{private: int b;public: A(int num):b(num){cout<<"带参构造函数！"<<endl;} A(){cout<<"不带参构造函数！"<<endl;} ~A(){cout<<"析构函数！"<<endl;}};A fun(A c){ r

静态成员变量不专属于某个对象，他属于整个类中所有对象的成员变量，在实例化一个对象的时候可能无法给它开辟内存，因此我们需要在全局为他开辟内存。#includeusing namespace std;class A { public: static int count; A(int i):key(i) { count++; cout<<"构造函数！"<<endl;

先看一段容易犯错的代码段：#includeusing namespace std;char* GetMe(){ char st[]="hello word!"; return st; }int main(){ char *str; str=GetMe(); cout<<str<<endl; return 0;}该段代码可能输出正确结果，也可能输出错误结果。原

先看一段代码：#includeusing namespace std;void GetMe(char *p,int num){ p=(char*)malloc(sizeof(char)*num); }int main(){ char *str=NULL; GetMe(str,100); strcpy(str,"Hello!"); cout<<str<<endl; re

#include#include#includeusing namespace std;int main(){ bitset bit[10]; string st[10]={"1011","11","110","1101","101","111","1100","100","1000","1111"}; int i; for(i=0;i<10;i++) { bitset

int a[2][2]={ {4, 6}, {9, 11} };我定义了这样一个数组，我想把这个数组作为参数，传递到一个函数中，并要在函数中能引用该二维数组的元素，我该怎么做？ 第一种方式是直接传递二维数组，但是必须标明第二维的值，因为如果只是传递a[][],编译器无法分配这样的数组，所以要这样传int a[][3]第二种方法是传递指针数组方式，即int (*a)[3]第三

先给出问题：像下面这样的数组，在函数中如何传参？也就是说如何保证虚参与实参类型一致。char str_arr[3][10] = {"yes","no","uncertain"};char *str_array[] = {"yes","no","unsure"};函数原型：               void func1( char (*a)[10] )

首先，作为extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数

1) #define是预处理指令，在编译预处理时进行简单的替换，不作正确性检查，不关含义是否正确照样带入，只有在编译已被展开的源程序时才会发现可能的错误并报错。例如：#define PI 3.1415926 程序中的：area=PI*r*r 会替换为3.1415926*r*r 如果你把#define语句中的数字9 写成字母g 预处理也照样带入。 2）typedef是在编译时处理

函数值按引用返回常见的一个错误：先来看一个错误代码：#includeusing namespace std;class A{private: int a;public: A(int num):a(num){cout<<"构造函数！"<<endl;} A(A &b) { a=b.a; cout<<"复制构造函数！"<<endl; } ~A() { cout

#include using namespace std;int count = 3;int main(){ int i, sum, count = 2; //输出main函数的count即为2 //cout<<count<<endl; for(i = 0, sum = 0; i < count; i += 2,count++) { //输出main函数的count即为每次循

题目：有100盏灯和100个开关，刚开始的时候等全是灭的，someone第一轮按下所有开关（开的按一下变灭，灭的按一下变开），第二轮隔一个按一下（偶数个按），第三轮隔2个（3的倍数个按），求第100轮之后有多少盏灯是亮的。本题有三个层次的解法：第一个层次是暴力解法，即循环100轮，分别记录每一盏等的状态，最后统计一下亮灯的个数即可。此方法为下策，代码不必赘述。第二个层次是加入一些分析技巧。

#includeusing namespace std;class A{public: virtual void fun1() { cout<<"A fun1"<<endl; } void fun2() { cout<<"A fun2"<<endl; }};class B :public A{public: void fun1

C++的类型转换符 使用标准C++的类型转换符：static_cast、dynamic_cast、reinterpret_cast、和const_cast。1static_cast用法：static_cast(expression) 该运算符把 expression 转换为 type-id 类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种

打印一个N*N的方阵，N为每边字符的个数（ 3〈N〈20 ），要求最外层为"X"，第二层为"Y"，从第三层起每层依次打印数字0，1，2，3，...例子：当N =5，打印出下面的图形：X X X X XX Y Y Y XX Y 0 Y XX Y Y Y XX X X X X 分析：该矩阵是一个原点对称矩阵，只要求出左上角的四分之一矩阵然后通过映射就可以。具体代码如

答案：a.成员函数被重载的特征：（1）相同的范围（比如在同一个类中）；（2）函数名字相同；（3）参数不同；（4）virtual 关键字可有可无。b.覆盖是指派生类函数覆盖基类函数，特征是：（1）不同的范围（分别位于派生类与基类）；（2）函数名字相同；（3）参数相同；（4）基类函数必须有virtual 关键字。c.“隐藏”是指派生类的函数屏蔽了与其同名的基

1.以下代码输出结果是intp=1;int q=-1;int i=-p++-q;printf("%d \n",i);答:结果是0。i=-p++-q;相当于i=-p-q;p++;最后p=2，q=-1。因为-的优先级大于++，2。以下代码输出结果是什么？注：原题为第三列代码，前两列为作为对照添加的代码#includeusing namespacest

从 C++ 托管到 Visual C++，类构造函数的初始化顺序已经发生变化。构造函数初始化顺序的比较在 C++ 托管扩展中，构造函数的初始化是按以下顺序进行的：如果存在基类的构造函数则调用该构造函数。计算该类的初始化列表。执行类构造函数的代码正文。此执行顺序与本机 C++ 编程遵守相同的约定。 新 Visual C++ 语言规定了 CLR 类的

const对象只能调用const成员函数：#includeusing namespace std;class A { public: void fun()const { cout<<"const 成员函数!"<<endl; } void fun() { cout<<"非const成员函数 !"<<endl; }}; int main(){ con

1、在申请方式上的不同：栈是系统自动分配的，使用完后系统自动删除。堆是手动分配，使用完后手动删除。2、系统响应的不同：只要栈的剩余空间大于所申请的空间，系统就会为程序提供内存，否则系统提示栈溢出错误。但是系统收到堆申请空间，系统会遍历用于记录空闲内存的链表，直到找到满足大小的内存空间，，当找到后，系统就从内存空闲链表中删除，将该段内存分配给堆，同时在该段内存中的首地址处标记堆的大小。如果这

C++本身并没有提供任何多线程机制，但是在windows下，我们可以调用SDK win32 api来编写多线程的程序，下面我就此简单的讲一下：创建线程的函数 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD SIZE_T dwStackSize,

程序员必须让拥有依赖关系的进程集协调，这样才能达到进程的共同目标。可以使用两种技术来达到协调。第一种技术在具有通信依赖关系的两个进程间传递信息。这种技术称做进程间通信（interprocess communication）。第二种技术是同步，当进程间相互具有合作依赖时使用。这两种类型的依赖关系可以同时存在。一般而言，进程有单独的地址空间。我们可以了解下可执行程序被装载到内存后建立的一系列映射等

调用(calling)机制从汇编时代起已经大量使用：准备一段现成的代码，调用者可以随时跳转至此段代码的起始地址，执行完后再返回跳转时的后续地址。 CPU为此准备了现成的调用指令，调用时可以压栈保护现场，调用结束后从堆栈中弹出现场地址，以便自动返回。借堆栈保护现场真是一项绝妙的发明，它使调用者和被调者可以互不相识，于是才有了后来的函数和构件，使吾辈编程者如此轻松愉快。若评选对人类影响最大之发明，在火

1）全局静态函数只在本编译单元有效。 2）类静态函数，对比普通成员函数，没有this指针，不能访问非static成员。 3）要说二者相同点，都是c++名字控制的手段：全局静态函数被局限在一个编译单元，通俗的将就是在一个cpp文件中定义的全局静态函数在另一个cpp文件中不能被调用。例程如下；//   main.cpp #include   extern   int   he

hpp，其实质就是将.cpp的实现代码混入.h头文件当中，定义与实现都包含在同一文件，则该类的调用者只需要include该hpp文件即可，无需再将cpp加入到project中进行编译。而实现代码将直接编译到调用者的obj文件中，不再生成单独的obj，采用hpp将大幅度减少调用 project中的cpp文件数与编译次数，也不用再发布烦人的lib与dll，因此非常适合用来编写公用的开源库。

为了保证数组动态存储过程中不越界，可以利用C++的类定义一种更安全功能更强的类型，可以为该类定义重载下标操作符[]函数，例程如下： #includeusing namespace std;class A{public: A(){}; A(int l):length(l) { size=new char[length]; } ~A() {

#includeusing namespace std;int main(){ char a[100];// cin>>a;// cin.get(a,13); gets(a); cout<<a<<endl;}使用cin>>a如果输入字符串带空格，则只输出空格前面的字符。解决的方法是下面两种输入方式。

#includeusing namespace std;class A{public: virtual void fun() { cout<<"A"<<endl; }};class B:public A{public: virtual void fun() { cout<<"B"<<endl; }};int main()

引用就是别名！别名的地址就是被引用的对象或变量的地址。 #includeusing namespace std;int main(){ int a=9; int &b=a; cout<<&a<<endl<<&b<<endl; return 0;}输出为：0012FF60    0012FF60  说明引用的地址与被引用的相同。我们可以定义一个对象的引

按值传递对象时，会调用该对象的复制构造函数创建一个临时副本，如果返回值也是对象则又要调用该对象的复制构造函数来创建一个临时副本。例程如下：#includeusing namespace std;class A{public: A() { cout<<"调用构造函数"<<endl; } //复制构造函数 A(A&) { cout<<"调用复制构

引用就是别名！别名的地址就是被引用的对象或变量的地址。 #includeusing namespace std;int main(){ int a=9; int &b=a; cout<<&a<<endl<<&b<<endl; return 0;}输出为：0012FF60    0012FF60  说明引用的地址与被引用的相同。我们可以定义一个对象的引

数据在内存中的存放方式 栈：由编译器自动分配，并自动回收，该区域一般存放函数的参数，局部变量等。堆：一般由程序员手动分配，并手动撤销。若程序员不释放，程序结束时可能由操作系统回收。全局区：全局变量和静态变量是存储在一起的，初始化的全局变量和静态变量放在一个区域，未初始化的放在相邻的区域。程序结束后由系统释放。文字常量区：存放常量字符串，程序结束后由系统释放。程序代码区:存放函数

#includeusing namespace std;inline void fun(int x);int main(){ int a; a=3; fun(a); return 0;}void fun(int x){ cout<<x<<endl;}一般情况下我们可以将类的数据成员设置为私有，而使用类的公有函数来访问他们，这样的好处是数据

只要类中包含一个纯虚函数该类就是抽象类。例程如下：#includeusing namespace std;class A{public: A() { } virtual void fun()=0; virtual void two()=0; virtual ~A() { cout<<"A Dis"<<endl; }};class

此题可有多种方法，大概可以分为两种：一种是制表法，另一种就是通俗的数学方法。其中数学方法中一个简单明了的方法就是利用一个while循环，采用按位与的方式。代码如下：#includeusing namespace std;int main(){ int a; int count; while(cin>>a&&a) { count=0; while(a>0)

/*对于multimap的使用只需要包含map的头文件即可*/#include#include#include#includeusing namespace std;int main(){ seta; a.insert("aef"); a.insert("efe"); set::iterator it=a.find("aef"); cout<

#include#include#include#includeusing namespace std;int main(){ maptransmap; ifstream is; is.open("E:\\coding\\String\\Debug\\2.txt"); char st[100]={0}; while(is>>st) { stri