<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[cap77的专栏]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/cap77</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; cap77]]></copyright><item><title><![CDATA[他们在清华的那几年——清华学长语录]]></title><link>https://blog.csdn.net/cap77/article/details/6893165</link><guid>https://blog.csdn.net/cap77/article/details/6893165</guid><author>cap77</author><pubDate>Fri, 21 Oct 2011 10:38:48 +0800</pubDate><description><![CDATA[（一）  
永远不要说你已经尽力了

我在高中时体育特别差，跑1000米都很要命，从来都是不及格。到了清华之后，第一节体育课，老师告诉我们每年要测3000米长跑，跑不过不许毕业，取消推研资格。怎么办？于是每天晚上10：30，我们的自习教室关门，操场上的人就多起来了。跑半个小时再回寝室继续学习，练了一个学期，我瘦了40斤，最后考试的时候我仅用了12分56秒就跑下了3000米，我们班最胖的人也在]]></description><category></category></item><item><title><![CDATA[深入理解C++的动态绑定和静态绑定]]></title><link>https://blog.csdn.net/cap77/article/details/6748948</link><guid>https://blog.csdn.net/cap77/article/details/6748948</guid><author>cap77</author><pubDate>Mon, 05 Sep 2011 10:58:53 +0800</pubDate><description><![CDATA[为了支持c++的多态性，才用了动态绑定和静态绑定。理解他们的区别有助于更好的理解多态性，以及在编程的过程中避免犯错误。
需要理解四个名词：
1、对象的静态类型：对象在声明时采用的类型。是在编译期确定的。
2、对象的动态类型：目前所指对象的类型。是在运行期决定的。对象的动态类]]></description><category></category></item><item><title><![CDATA[自定义链栈]]></title><link>https://blog.csdn.net/cap77/article/details/6339276</link><guid>https://blog.csdn.net/cap77/article/details/6339276</guid><author>cap77</author><pubDate>Thu, 21 Apr 2011 17:27:00 +0800</pubDate><description><![CDATA[#include 
#include 

using namespace std;

template
struct Node
{
   T data;
   Node *next;
};

template
class LinkStack
{
public:
   LinkStack()
   {
      top=NULL;
	  size=0;
   }
   ~LinkStack();
   void Push(char x);
   void Pop]]></description><category></category></item><item><title><![CDATA[复杂度为o(n)的计数排序]]></title><link>https://blog.csdn.net/cap77/article/details/6339111</link><guid>https://blog.csdn.net/cap77/article/details/6339111</guid><author>cap77</author><pubDate>Thu, 21 Apr 2011 16:47:00 +0800</pubDate><description><![CDATA[<br />假定给定的一串正数，且最大值已知，可以使用这种排序。<br />#include<iostream>
using namespace std;
const int N=10;

void countsort(int *a,int len)
{
	int count[256]={0};//假设最大值为256，这个数组用来标记每个数出现的次数
    for(int i=0;i<len;i++)
		count[a[i]]++;
	int *temp=new int[len];
]]></description><category></category></item><item><title><![CDATA[编写复数类以及++前置和后置的区别]]></title><link>https://blog.csdn.net/cap77/article/details/6339094</link><guid>https://blog.csdn.net/cap77/article/details/6339094</guid><author>cap77</author><pubDate>Thu, 21 Apr 2011 16:41:00 +0800</pubDate><description><![CDATA[<br />#include "iostream.h"  //不这样使用头文件会报错fatal error C1001: INTERNAL COMPILER ERROR
                       //不知为什么
//using namespace std;

class complex
{
public:
    complex() { real=imag=0; }
    complex(double r, double i)
	{
       real = r;]]></description><category></category></item><item><title><![CDATA[用栈实现括弧匹配]]></title><link>https://blog.csdn.net/cap77/article/details/6339002</link><guid>https://blog.csdn.net/cap77/article/details/6339002</guid><author>cap77</author><pubDate>Thu, 21 Apr 2011 16:24:00 +0800</pubDate><description><![CDATA[#include
#include
using namespace std;

void Bracket(char *a,int len)
{
	stack temp;
	for(int i=0;i]]></description><category></category></item><item><title><![CDATA[C++中的单例模式]]></title><link>https://blog.csdn.net/cap77/article/details/6280146</link><guid>https://blog.csdn.net/cap77/article/details/6280146</guid><author>cap77</author><pubDate>Sat, 26 Mar 2011 16:40:00 +0800</pubDate><description><![CDATA[<br /> 单例模式也称为单件模式、单子模式，可能是使用最广泛的设计模式。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。<br />单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，但这样的代码显的很不优雅。 使用全局对象能够保证方便地访问实例，但是不能保证只声明一个对象——]]></description><category></category></item><item><title><![CDATA[位图法]]></title><link>https://blog.csdn.net/cap77/article/details/6272453</link><guid>https://blog.csdn.net/cap77/article/details/6272453</guid><author>cap77</author><pubDate>Wed, 23 Mar 2011 21:38:00 +0800</pubDate><description><![CDATA[<br />在 8K 字节的内存空间内，如何存 unsigned short 类型数据？ <br />一般做法： <br />定义一个数组： unsigned short arrNormal[4096]; <br />这样做，最多只能存 4K 个 unsigned short 数据。 <br />  <br />利用位图法： <br />定义一个数组： unsigned char arrBit[8192]; <br />这样做，能存 8K*8=64K 个 unsigned short 数据。 <br /> ]]></description><category></category></item><item><title><![CDATA[任意两个整数相加]]></title><link>https://blog.csdn.net/cap77/article/details/6272352</link><guid>https://blog.csdn.net/cap77/article/details/6272352</guid><author>cap77</author><pubDate>Wed, 23 Mar 2011 21:00:00 +0800</pubDate><description><![CDATA[#include 
using namespace std;


void ReverseStr(char *result)
{
	int len=strlen(result);
	char *end=result+len-1;
	char *start=result;
	while (end>=start)
	{
		char temp=*end;
		*end=*start;
		*start=temp;
		end--;
		start++;
	}
}

///两]]></description><category></category></item><item><title><![CDATA[字符串全排列]]></title><link>https://blog.csdn.net/cap77/article/details/6272271</link><guid>https://blog.csdn.net/cap77/article/details/6272271</guid><author>cap77</author><pubDate>Wed, 23 Mar 2011 20:38:00 +0800</pubDate><description><![CDATA[#include
using namespace std;

int array[100]={0};
void permutation(char a[],int start,int end)  // 找出字符串的全排列(允许输入有重复字符) 
{
   int i;
   char temp;
   if(start==end)
   {
	   for( i=0;i]]></description><category></category></item><item><title><![CDATA[C++的四个类型转换]]></title><link>https://blog.csdn.net/cap77/article/details/6238361</link><guid>https://blog.csdn.net/cap77/article/details/6238361</guid><author>cap77</author><pubDate>Thu, 10 Mar 2011 20:39:00 +0800</pubDate><description><![CDATA[C++的四个类型转换运算符已经有很久了,但一直没有弄清楚它们的用法,今天看到一本书上的解释,才大致地的了解了其具体的用法.具体归纳如下:reinterpret_cast（在编译期间实现转换）该函数将一个类型的指针转换为另一个类型的指针.这种转换不用修改指针变量值存放格式(不改变指针变量值),只需在编译时重新解释指针的类型就可做到.reinterpret_cast 可以将指针值转换为一个整型数,但不能用于非指针类型的转换.例:
//基本类型指针的类型转换
double d=9.2;
double* pd]]></description><category></category></item><item><title><![CDATA[图的邻接表及遍历]]></title><link>https://blog.csdn.net/cap77/article/details/6221756</link><guid>https://blog.csdn.net/cap77/article/details/6221756</guid><author>cap77</author><pubDate>Thu, 03 Mar 2011 20:42:00 +0800</pubDate><description><![CDATA[#include 
#include 
using namespace std;

const int num=100;
bool flag[num]={false};
struct EdgeNode;
struct  AdjList{
	char vextex;
	EdgeNode* next;
};  //顶点表

struct EdgeNode{
	int adjvex;
	EdgeNode* next;
};  //边表

struct Graph{
	int V]]></description><category></category></item><item><title><![CDATA[图的邻接矩阵及其遍历]]></title><link>https://blog.csdn.net/cap77/article/details/6214708</link><guid>https://blog.csdn.net/cap77/article/details/6214708</guid><author>cap77</author><pubDate>Tue, 01 Mar 2011 09:53:00 +0800</pubDate><description><![CDATA[#include 
#include 
using namespace std;

const int MaxNum=100;
bool flag[MaxNum]={false};
struct Graph
{
	int VertexNum;  //顶点数
	int SideNum;  //边数
	char vexs[MaxNum];  //顶点表
	int  AdjacentMatrix[MaxNum][MaxNum];  //邻接矩阵
};

void CreateGraph]]></description><category></category></item><item><title><![CDATA[动态申请二维数组并释放]]></title><link>https://blog.csdn.net/cap77/article/details/6212500</link><guid>https://blog.csdn.net/cap77/article/details/6212500</guid><author>cap77</author><pubDate>Mon, 28 Feb 2011 10:09:00 +0800</pubDate><description><![CDATA[<br />#include <iostream>
using namespace std;

//定义类型A
class A
{
public:
    friend class B;  //类型B为友元类
private:
    int **p;                //指向二级数组
    int m_n1;                //行数
    int m_n2;                //列数

public:
    A(int n1, ]]></description><category></category></item><item><title><![CDATA[二叉树的创建，遍历等操作]]></title><link>https://blog.csdn.net/cap77/article/details/6043850</link><guid>https://blog.csdn.net/cap77/article/details/6043850</guid><author>cap77</author><pubDate>Mon, 29 Nov 2010 20:59:00 +0800</pubDate><description><![CDATA[#include 
#include 
using namespace std;

const int MaxSize=100;

struct BitTree
{
	char data;
	BitTree *lchild;
	BitTree *rchild;
};

void CreatBitTree(BitTree *&T)
{
	char temp;
	cin>>temp;
	if (temp=='#')
	{
		T=NULL;
	}
	else
	{
]]></description><category></category></item><item><title><![CDATA[八皇后问题]]></title><link>https://blog.csdn.net/cap77/article/details/6033270</link><guid>https://blog.csdn.net/cap77/article/details/6033270</guid><author>cap77</author><pubDate>Wed, 24 Nov 2010 20:59:00 +0800</pubDate><description><![CDATA[     在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，这就是八皇后问题。有人用图论的方法解出共有92种摆法，这里用c++实现：#include  
using namespace std;   

class EightQueens{
public:
	EightQueens(int sum);
	virtual ~EightQueens();
	bool Isvalid(int col, int row);
	void Prin]]></description><category></category></item><item><title><![CDATA[指针的引用与正常指针]]></title><link>https://blog.csdn.net/cap77/article/details/6015329</link><guid>https://blog.csdn.net/cap77/article/details/6015329</guid><author>cap77</author><pubDate>Wed, 17 Nov 2010 17:16:00 +0800</pubDate><description><![CDATA[一、先看一段代码：#include usingnamespace std;void freePtr1(int* p1){   delete p1;    p1 = NULL;}void freePtr2(int*& p2){   delete p2;    p2 = NULL;}void main(){   int *p1 = newint;   *p1 = 1;   freePtr1(p1);   int *p2 = newint;   *p2 = 2;   freePtr2(p2);   system(]]></description><category></category></item><item><title><![CDATA[实例详解C++友元]]></title><link>https://blog.csdn.net/cap77/article/details/5987689</link><guid>https://blog.csdn.net/cap77/article/details/5987689</guid><author>cap77</author><pubDate>Thu, 04 Nov 2010 16:35:00 +0800</pubDate><description><![CDATA[在说明什么是友元之前，我们先说明一下为什么需要友元与友元的缺点: 　　通常对于普通函数来说,要访问类的保护成员是不可能的，如果想这么做那么必须把类的成员都生命成为public(共用的)，然而这做带来的问题遍是任何外部函数都可以毫无约束的访问它操作它，c++利用friend修饰符，可以让一些你设定的函数能够对这些保护数据进行操作，避免把类成员全部设置成public，最大限度的保护数据成员的安全。 　　友元能够使得普通函数直接访问类的保护数据，避免了类成员函数的频繁调用，可以节约处理器开销，提高程序的效率，但矛]]></description><category></category></item><item><title><![CDATA[static变量和函数]]></title><link>https://blog.csdn.net/cap77/article/details/5986417</link><guid>https://blog.csdn.net/cap77/article/details/5986417</guid><author>cap77</author><pubDate>Thu, 04 Nov 2010 09:21:00 +0800</pubDate><description><![CDATA[首先static变量只有一次初始化，不管在类中还是在函数中..有这样一个函数：void Foo()   
{   
    static int a=3; // initialize    
    std::cout 这里的static int a=3只执行了一次。在main中调用Foo()两次，结果为34.将上面的函数改为void Foo()   
{   
    static int a;   
        a=3;           // not initialize   
 ]]></description><category></category></item><item><title><![CDATA[拷贝构造函数和赋值表达式的区别]]></title><link>https://blog.csdn.net/cap77/article/details/5986405</link><guid>https://blog.csdn.net/cap77/article/details/5986405</guid><author>cap77</author><pubDate>Thu, 04 Nov 2010 09:09:00 +0800</pubDate><description><![CDATA[拷贝构造函数和赋值表达式的区别一、引入    拷贝构造函数，是用新创建的对象来初始化某内存区域，对于一个已经被初始化的对象来进行operator=操作。class   A;   A a;A b=a;   //拷贝构造函数调用A b(a);   //拷贝构造函数调用A a;A b;b =a;   //赋值运算符调用拷贝构造函数首先是一个构造函数，它调用的时候产生一个对象，是通过参数传进来的那个对象来初始化，产生的对象。operator=();是把一个对象赋值给一个原有的对象，所以如果原来的对象中有内存分配要先]]></description><category></category></item></channel></rss>