yiruirui0507的专栏

一、预备知识—程序的内存分配 <br />$ H- ^' M+ d8 t9 L! ~+ A2 t! d  v# s一个由C/C++编译的程序占用的内存分为以下几个部分 5 }7 U/ U( f- d* X; {<br />1、栈区（stack）—   由编译器自动分配释放   ，存放函数的参数值，局部变量的值等。其 <br />/ o7 {( l7 E: t  m操作方式类似于数据结构中的栈。 <br />. C& k6 o2 N0 D/ Z2、堆区（heap）   —   一般由程序员分配释放，   若程

<br />record lookup( phone);<br />record lookup(const phone);<br />这两个属于函数重载吗？<br />这个还需要从实参与形参之间的关系中去寻找答案，这对的区别仅仅在于是否将形参定义为const，这种差异并不影响传递到函数的对象，因此第二个函数声明被视为第一个的重复声明。<br />原因：实参传递方式。复制实参的副本给形参时并不考虑形参是否为const，因为函数操纵的只是副本。函数无法修改实参。因此，既可将const对象传递给const形参，也

<br />class constref<br />{<br />public:<br />constref(int ii);<br />private:<br />int i;<br />const int ci;<br />int &ri;<br />};<br />constref::constref(int ii)<br />{<br />i=ii;<br />ci=ii;<br />ri=i;<br />}<br />这个构造函数的使用明显是错误的.<br />ci是const 类型,只能被初始化

<br />class A{public: A(int i){x=i;} int get(){return x;}private: int x;};A & func(){ A a(23); return a;}int main(){ A&r=func(); cout<<r.get()<<endl; return 0;}<br />由于对象a是个局部对象，因此当函数对象func结束后，局部对象a也就被删除了。由于对象a消失了，所以Func

<br /><br />一个由c/C++编译的程序占用的内存分为以下几个部分 <br />1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 <br />2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。 <br />3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初

<br />#include<iostream>#include<string>using namespace std;class animal{ string name; int age;public: animal(string name,int age=0) { this->name=name; this->age=age; } animal& operator+(animal& a); friend ostream& operator <<

<br />#include "stdafx.h"<br />#include<iostream><br /><br />using std::cout;<br />using std::endl;<br />class X{<br />public:<br />X(int t=10):val(t){}<br />//friend void fun(const X &);//声明<br />friend void fun(const X &orj){cout<<orj.val<<endl;};<br />f

<br />class A{private: static int aa; static const int count=0; const int bb;public: A(int a); static void print();};A::A(int a):bb(a){ aa+=1;}void A::print(){ cout<<"count="<<count<<endl; cout<<"aa="<<aa<<endl;}int A:

<br />在C++中， 构造函数，拷贝构造函数，析构函数和赋值函数(赋值运算符重载)是最基本不过的需要掌握的知识。 但是如果我问你“拷贝构造函数的参数为什么必须使用引用类型？”这个问题， 你会怎么回答？ 或许你会回答为了减少一次内存拷贝？ 很惭愧的是，我的第一感觉也是这么回答。不好还好，我有理性这个好品质。思索一下以后，发现这个答案是不对的。让我来撕开(有点暴力，但是我喜欢，嘿嘿--龇牙)那件隐藏在真理外的小裤衩，让它袒露在“登徒子”们的眼前吧。<br />先从一个小例子开始：（自己测试一下自己看看这个程

<br />#include<iostream>#include<stdio.h>using namespace std;class String{public: char* get(){return m_data;} String(const char *str=NULL); String(const String& other); ~String(); String& operator=(const String& other);private: ch

<br />昨天花了不少时间下载---安装上了VS2008，今天写一个小的C++项目就发现了这个古怪的问题，查找资料后发现这是微软的一个BUG，具体的解决办法官网上有介绍。<br /> <br />方法仍与FAT32有关：在项目的“属性｜配置属性｜清单工具｜常规(Project | Game Properties | Configuration Properties | C/C++ | Code Generation | Runtime Library)”中的“使用FAT32解决办法”选择“是”（默认为“否

<br />#include<iostream>#include<conio.h>using namespace std;#define MAX 8int sum=0;class QueenPuzzle{ int queens[MAX];public: void printOut(); int IsValid(int n); void placeQueen(int i);};void QueenPuzzle::printOut(){ for(i

<br />在C语言中，假设我们有这样的一个函数：<br /><br />int function(int a,int b)<br /><br />调用时只要用result = function(1,2)这样的方式就可以使用这个函数。但是，当高级语言被编译成计算机可以识别的机器码时，有一个问题就凸现出来：在CPU中，计算机没有办法知道一个函数调用需要多少个、什么样的参数，也没有硬件可以保存这些参数。也就是说，计算机不知道怎么给这个函数传递参数，传递参数的工作必须由函数调用者和函数本身来协调。为此，计算机提供

<br />例如: <br />class a <br />{public: <br />int aa}; <br />class b:public a <br />{public: <br />int bb; <br />} <br />从内存的来看 <br />如a <br />－－－－－－－－－| <br />|占一个int数据大小--| <br />|----（aa数据）------| <br />|－－－－－－－－－ <br />而b则是 <br />－－－－－－－－－|－－－－－－－－－ <br

<br />什么是操作符重载？一看到重载，很容易就让人联想到成员函数重载，函数重载可以使名称相同的函数具有不同的实际功能，只要赋给这些同名函数不同的参数就可以了，操作符重载也是基于这一机制的。系统为我们提供了许多操作符，比如“＋”，“[ ]”等，这些操作符都有一些默认的功能，而操作符重载机制允许我们给这些操作符赋予不同的功能，并能够按照普通操作符的使用格式来使用自己定义功能的操作符（即重载的操作符）。定义之后，我们就可以按照平常使用操作符的格式来使用我们自己的重载操作符了。操作符重载一般在类内部定义，就像成

<br />很久很久以前，有一群人，他们决定用8个可以开合的晶体管来组合成不同的状态，以表示世界上的万物。他们看到8个开关状态是好的，于是他们把这称为"字节"。 <br /><br />再后来，他们又做了一些可以处理这些字节的机器，机器开动了，可以用字节来组合出很多状态，状态开始变来变去。他们看到这样是好的，于是它们就这机器称为"计算机"。 <br /><br /><br /><br />开始计算机只在美国用。八位的字节一共可以组合出256(2的8次方)种不同的状态。 <br /><br />他们把其中的编

<br />对于具有类类型的成员，则会调用该成员所属类自身的默认构造函数实现初始化。<br />内置类型成员的初值依赖于对象如何定义，如果对象在全局作用域中定义或定义为静态局部对象，则这些成员将被初始化为0。如果对象在局部作用域中定义，则这些成员没有初始化。<br /> <br />class A<br />{<br /> int a;<br />public:<br /> int get()<br /> {<br />  return a;<br /> }<br />};<br />A a;<br />v

bool test(string &s){return s.empty();}这个函数本身是合法的，但是有些局限性，比如如果传递常量字符串就不行，比如：test("我爱张柏芝")就必然出错因为 非cosnt的形参只能与完全同类型的非const的对象关联。所以应该改为 bool test(const string &s){return s.empty();}比较合理。

动态分配数组时，如果数组元素具有类类型，将使用该类的默认构造函数实现初始化；如果数组元素是内置类型，则无初始化。string *psa=new string [10];int *pia=new int [10];这两个new表达式都分配了10个对象的数组，第一个数组是string类型，分配了存储对象的空间后，会调用string类型的默认构造函数依次初始化数组中的每个元素。第二个数组为内置类型，分配了存储10个int对象的内从空间，并没 初始化。可以跟在数组后面加一对空圆括号，对数组元素进行初始化。int *

<br />C语言所有复杂的指针声明，都是由各种声明嵌套构成的。如何解读复杂指针声明呢？右左法则是一个既著名又常用的方法。不过，右左法则其实并不是C标 准里面的内容，它是从C标准的声明规定中归纳出来的方法。C标准的声明规则，是用来解决如何创建声明的，而右左法则是用来解决如何辩识一个声明的，两者可 以说是相反的。右左法则的英文原文是这样说的：<br />The right-left rule: Start reading the declaration from the innermost parenthes

<br />写好C语言，好看的宏定义很主要，运用宏定义可以防止 出错，提高可移植性，可读性，方便性 等等。下面列举一些成熟软件中常用得宏定义……<br />1，防止 一个头文件被重复包含<br />　　 #ifndef COMDEF_H<br />　　 #define COMDEF_H<br />　　 //头文件内容<br />　　 #endif<br />2，重新定义一些类型，防止 由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植。<br />　　 typedef unsigned char

<br />最近有朋友问如下问题:<br />#include <stdio.h><br />#include <stdlib.h><br />#include <iconv.h><br />#include <time.h><br />int main()<br />{<br />struct tm *tms;<br />time_t now = time(0);<br />tms = localtime(&now);<br />printf("%d/n", tms->tm_year);<br />pri

Visual Studio 2008Visual Studio 2005<br />Format a time string.Copysize_t strftime( char *strDest, size_t maxsize, const char *format, const struct tm *timeptr );size_t wcsftime( wchar_t *strDest, size_t maxsize, const wchar

<br />众所周知，荷兰国旗由红色，白色和蓝色3种颜色组成。现在假设有很多这3种颜色的线被存放在一个数组里面，要求每次操作只能进行一次交换，对数组进行一遍扫描后，3种颜色自然分开，颜色顺序应为红，白，蓝。要求时间复杂度O(n)，使移动次数最少。<br />解决思路：荷兰国旗问题其实就是一个排序问题，可以将红，白，蓝3种颜色分别用数字0,1,2表示，用一个数组来存储他们。将相同颜色线条归为一类就相等于将数组中的数值按大小进行排序，只不过数组里存储的只有3种数值而已。解题的基本策略是遍历两个颜色区域，如果颜色

什么是缓冲区缓冲区又称为缓存，它是内存空间的一部分。也就是说，在内存空间中预留了一定的存储空间，这些存储空间用来缓冲输入或输出的数据，这部分预留的空间就叫做缓冲区。缓冲区根据其对应的是输入设备还是输出设备，分为输入缓冲区和输出缓冲区。为什么要引入缓冲区我们为什么要引入缓冲区呢？比如我们从磁盘里取信息，我们先把读出的数据放在缓冲区，计算机再直接从缓冲区中取数据，等缓冲区的数据取完后再去磁盘中读取，这样就可以减少磁盘的读写次数，再加上计算机对缓冲区的操作大大快于对磁盘的操作，故应用缓冲区可大大提高计算机的运行速

<br />#include<iostream><br />using namespace std;<br />class Time<br />{<br /> int hour,minute,second;<br />public:<br /> Time():hour(0),minute(0),second(0)<br /> {};<br /> Time(Time &t);<br /> void getTime();<br /> void setTime(int h,int m,int s);<br />}

#includeusing namespace std;class Person{ char *name;int age;public: Person() {name=NULL;age=20;}; void Init(int size,int age) {  name=new char[size];  this->age=age; } int getAge(){return age;} char *getName(){return name;} void setAge(int age){this->age=

<br />应用数组可以实现的算法和解决的问题很多，这里举个非常典型的例子------大整数乘法。由于计算机的精度是有限的，因此单纯使用程序设计语言提供的原子数据类型来完成两个大整数的乘法显然是不切实际的。可以考虑用两个数组来分别存储一些小于10的整数，这些数字按顺序排列在一起，分别表示一个大整数的每一位上的数字，于是大整数的存储问题就解决了。然后按照基本乘法规则对这两个大整数进行运算即可。代码如下：<br />#include<iostream><br />#include<memory><br />us

<br />PS:15个人排成一圈，给他们1-15的编号，现在从1开始报数，报数字4的人退出，余下的人从退出的下一个位置开始继续刚才的报数，直到整个队列中只剩下一个人为止。请问：这个人是几号？<br />CirList.h<br />//CirListNode类#include<stdio.h>template <class T> class CirListNode{ T data; CirListNode<T>* link; public: CirListNode():lin

<br />问题描述：魔术师利用一副牌中的13张黑牌，预先将他们排好后叠放在一起，牌面朝下。对观众说：“我不看牌，只数数就可以猜到每张牌是什么，我大声数数，你们听，不信？现场演示。”魔术师将最上面的那张牌数为1，把他翻过来正好是黑桃A，将黑桃A放在桌子上，然后顺序从上到下数手上的余牌，第二次数1,2，将第一张牌放在这些牌的下面，将第二章牌翻过来，正好是黑桃2，也将它放在桌子上，第三次数1,2,3，将前面两张依次放在这些牌的下面，再翻第三章牌正好是黑桃3。这样依次进行将13张牌全部翻出，准确无误。<br />

拉丁方阵就是这样的比如4阶拉丁方阵1 2 3 42 3 4 13 4 1 24 1 2 3每行每列没重复的数字，这里借助循环单链表来实现，思路：第一遍历（第一行的数据）从第一个结点（注意不是头结点）开始，第二次遍历（第二行的数据）从第二个结点开始，一次类推。。。。。。代码如下：（比较容易看懂，没分.H文件很.CPP文件）//CirListNode类 #include template class CirListNode { T data; CirLi

<br />首先定义了一个类Date<br />#include<iostream>#include<iomanip>using namespace std;class Date{ int year,month,day;public: void set(int y,int m,int d); void set(string& s); bool isLeapYear()const; void print()const;};void

<br />主要就是一个主函数，关于链表类，上节有注释。<br />#include<stdio.h> template<class T> class DouListNode { T data; DouListNode<T>* link; DouListNode<T>* prior; public: DouListNode():link(NULL),prior(NULL

<br />Windows系统编程之进程间通信<br />作者：北极星2003<br />来源：看雪论坛（www.pediy.com）<br />Windows 的IPC（进程间通信）机制主要是异步管道和命名管道。（至于其他的IPC方式，例如内存映射、邮槽等这里就不介绍了）<br />管道（pipe）是用于进程间通信的共享内存区域。创建管道的进程称为管道服务器，而连接到这个管道的进程称为管道客户端。一个进程向管道写入信息，而另外一个进程从管道读取信息。<br />异步管道是基于字符和半双工的（即单向），一般