C++博客-&豪-随笔分类-C++之梦

真是水,居然可以这样将int转成str

Fri, 25 Jul 2008 03:34:00 GMT

   char result[100];
   int num=24;
   sprintf( result, "%d", num );

豪 2008-07-25 11:34 发表评论

内存池(version1.1)

Mon, 21 Apr 2008 08:15:00 GMT

摘要: 再参考了《Modern C++ Design》的FixedAllocator的设计，并且优化了一下算法，虽然最坏时间复杂度还是O(N)的，但是在通常情况下，new/delete的使用已经获得了比较好的性能了。Chunk.h和version1.0的差不多，只是去掉了析构函数，让Chunk直接被FixedAlloctor操作Chunk.h #ifndef CHUNK_H#define&nb... 阅读全文

豪 2008-04-21 16:15 发表评论

智能指针源码

Thu, 17 Apr 2008 09:01:00 GMT

智能指针源码，可像普通指针一样使用，但可以自动释放内存，代码很短，看一下就明白原理了。

#ifndef AUTOPTR
#define AUTOPTR

/**
* 智能指针类
*/
template<class T>
class AutoPtr {
public :
    AutoPtr(T* p = 0) : pointee(p) {} //默认构造函数

    template<class U>
        AutoPtr(AutoPtr<U>& rhs) : pointee(rhs.release()) {}//复制构造函数

    ~AutoPtr() {delete pointee;}

    template<class U>
    AutoPtr<T>& operator=(AutoPtr<U>& rhs) { //赋值函数
        if (this != &rhs) {
            reset(rhs.release());
        }
        return *this;
    }

    T& operator*() const {return *pointee;}

    T* operator->() const {return pointee;}

    T* get() const {return pointee;} //获取dumb pointer

    T* release() { //释放dumb pointer 的拥有权，并返回其值
        T* oldPointee == pointee;
        pointee = 0;
        return oldPointee;
    }

    void reset(T* p=0) { //重复置p指针
        if (pointee != p) {
            delete pointee;
            pointee = p;
        }
    }

private :
    T* pointee;
};

#endif AUTOPTR

test.cpp

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

int main() {
    AutoPtr<int> p = new int;
    *p = 100;
    printf("%d\n", *p);

    AutoPtr<string> sp = new string;
    *sp = "hello world";
    printf("%s\n", sp->c_str());
    return 0;
}

豪 2008-04-17 17:01 发表评论

More Effective 的 Reference Counting

Wed, 09 Apr 2008 13:36:00 GMT

摘要: 发觉计算机很多东西都是相同的，记得操作系统时候学过这一概率 copy on write，在Reference Counted中彻底用到，代码的设计确实精妙，可以在不修改客户端得类，利用RCIPtr间接指针，对客户端的类实现引用计数，太妙了，详细见代码吧，代码中Widget为已有的客户端的类，RCIPtr是一个间接指针，RCObject是引用计数的基类，所有需要引用计数的类都必须继承他，换句话说，R... 阅读全文

豪 2008-04-09 21:36 发表评论

从二叉树的递归遍历想到的:利用重载函数,使函数接口更"友好"

Tue, 14 Mar 2006 05:11:00 GMT

问题分析:
假设一个
struct TreeNode
{
int tData;
TreeNode *lp, *rp;//左右儿子的指针
};

规定用递归前序遍历以pNode为根二叉树,把节点指针保存在rs数组中,并返回节点个数cnt.

因为要用递归遍历, 所以cnt必须保留递归每层cnt的值.
实现方法有两种:
1:用by value传值,cnt初值为0;

int travel(TreeNode *pNode, TreeNode **rs, int &cnt)
{
    if (pNode == NULL)
    {
        return cnt;
    }
    rs[cnt++] = pNode;
    travel(pNode->lp, rs, cnt);
    travel(pNode->rp, rs, cnt);
    return cnt;
}

2:用静态变量实现
int travel(TreeNode *pNode, TreeNode **rs)
{
    static int cnt = 0;
    if (pNode == NULL)
    {
        return cnt;
    }
    rs[cnt++] = pNode;
    travel(pNode->lp, rs, cnt);
    travel(pNode->rp, rs, cnt);
    return cnt;
}

对比1和2,显然2的函数要比1的来得友好,因为在1中增加的参数cnt不属于函数接口,只是为了函数的实现而引入的,所以参数cnt的出现,破坏了接口的友好性.但是如果用2的方法,在函数再次使用的时候static int cnt的值仍保持上次函数被调用时的值,而没有初始化为0,从而达不到函数再次被调用的目的.那有没有好的解决方法呢?

我们利用函数重载,重载travel函数,并在此函数内调用1的travel函数.

int travel(TreeNode *pNode, TreeNode **rs)
{
int cnt = 0;
return travel(TreeNode *pNode, TreeNode **rs, int &cnt);
}

这样的话,就能很好的解决了函数接口的友好性,而又不会出现static变量的副作用了.

以上是小弟的一点愚见.

豪 2006-03-14 13:11 发表评论

又是一题动态规划--经典

Wed, 01 Mar 2006 13:50:00 GMT

原题：

滑雪
Time Limit:1000MS Memory Limit:65536K

Description
Michael喜欢滑雪百这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

 1  2  3  4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

Input
输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。

Output
输出最长区域的长度。

我提交的程序：

#include<iostream>
using namespace std;

const int MAX = 102;

struct pos
{
    int i,j,p;//i->行;j->列；p->来源方向
};

int path(int [MAX][MAX],int [MAX][MAX],int[][MAX],int,int);

int main()
{
    int input[MAX][MAX];
    int result[MAX][MAX];
    int status[MAX][MAX];
    int m,n;
    int i,j;
    int max,ans;
    cin>>m>>n;
    for (i = 0; i<=m+1; i++)
        for (j = 0; j<=n+1; j++)
        {
            input[i][j] = 10001;
            result[i][j] = 0;
            status[i][j] = 0;
        }

    for (i = 1; i<=m; i++)
        for (j = 1; j<=n; j++)
        {
            cin>>input[i][j];
        }

    for (i = 1; i<=m; i++)
        for (j = 1; j<=n; j++)
            path(input,result,status,i,j);

    max = 0;
    for (i = 1; i<=m; i++)
        for (j = 1; j<=n; j++)
            if (max<result[i][j])
                max = result[i][j];

    cout<<max<<endl;
    return 0;
}

int path(int input[MAX][MAX],int result[MAX][MAX],int status[MAX][MAX],int i,int j)
{
    pos pack[MAX*MAX];
    int max,g,h;
    int ii;
    int top = 0;
    int p = 0;
    int incr[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};//增量表

    //初始化
    if (result[i][j]>0)
    {
        return 0;
    }
    else
    {
        pack[top].i = i;
        pack[top].j = j;
        pack[top].p = p;
        status[i][j] = -1;
    }

    while (top>=0||p<4)
    {
        if (p<4)
        {
            g = pack[top].i+incr[p][0];
            h = pack[top].j+incr[p][1];
            //判断是否合法
            if (input[pack[top].i][pack[top].j]>input[g][h])
            {
               if (result[g][h]>0||status[g][h]==-1)//
                   p++;
               else
               {
                   //进栈
                   top++;
                   pack[top].i = g;
                   pack[top].j = h;
                   pack[top].p = p;
                   status[g][h] = -1;
                   p = 0;
               }
            }//合法
            else
            {
                p++;
            }
        }
        else//p==4时
        {
            max = 0;
            for (ii = 0; ii<4; ii++)//四个方向
            {
                g = pack[top].i+incr[ii][0];
                h = pack[top].j+incr[ii][1];
                if (input[pack[top].i][pack[top].j]>input[g][h]&&max<result[g][h])
                    max = result[g][h];
            }
            result[pack[top].i][pack[top].j] = max+1;
            top--;//回溯
            p = pack[top].p+1;
        }
    }
    return 0;
}

此题用到了回溯，和动态规划，也是经典，推荐acmer做做.欢迎交流:)

豪 2006-03-01 21:50 发表评论

看 c++primer 后的一个问题

Thu, 29 Dec 2005 16:21:00 GMT

书上说,当无法列出传递函数的所有实参的类型和数目时,可用省略号指定参数表
(...)

如:void foo(...);
void foo(parm_list,...);
void foo(...)
{
//...
}
调用:foo(a,b,c);

就是不懂,把a,b,c的值传进函数里面后,用什么变量来接收???如果不能接收,(...)岂不是没意义?
还有就是不明白
int printf(const char*...);
printf("hello,&s\n",userName);

这个c的输出函数是怎么用(...)实现的.

先谢了:)

豪 2005-12-30 00:21 发表评论

递归--->计算日期总数

Wed, 28 Dec 2005 15:12:00 GMT

知道写的很烂,发上来时希望各位兄台指点不足:)

先谢啦,呵呵.

#include<iostream>
using namespace std;

struct date
{
     unsigned int year,month,day;
};

unsigned int sum(unsigned int,unsigned int,unsigned int);
bool is_eyear(unsigned int);

void main()
{
     date temp;
     unsigned int total;
     cout<<"please input date,formation:2005 12 05"<<endl;
     cin>>temp.year>>temp.month>>temp.day;
     total=sum(temp.year,temp.month,temp.day);
     cout<<"total day="<<total<<endl;
}

unsigned int sum(unsigned int y,unsigned int m,unsigned int d)
{
     unsigned int t=0;
     if(m<1){
          t=0;
          return t;
     }else if(m==1){
          t=d;
          return t;
     }else{
          switch(m){
          case 3:
               if(is_eyear(y))
                      t=d+sum(y,m-1,29);
               else t=d+sum(y,m-1,28);
               break;
          case 2:case 4:case 6:case 8:case 9:case 11:
               t=d+sum(y,m-1,31);
               break;
          default :
               t=d+sum(y,m-1,30);
               break;
        }
   }
return t;
}//计算日期总数函数

/***************

bool is_eyear(unsigned int y)
{
     if(y%400==0) return 1;
     else if(y%4==0) return 1;
     else return 0;
}//判断闰年函数
**************/

bool is_eyear(unsigned int y)
{
     if(y%100==0&&y%400==0) return 1;
     if(y%100!=0&&y%4==0) return 1;
     return 0;
}//判断闰年函数

豪 2005-12-28 23:12 发表评论

不看书怎么见彩虹？

Sun, 27 Nov 2005 15:12:00 GMT

学校图书馆好多书啊，决定先把《数据结构与算法》和《Data Abstraction and Problem Solving with C++:Walls and Mirrors》，《C++primer》看完。上海交大的师兄在用asp.net2.0，高中时候的师兄开发的snowman已经update到snowman.s了，这个世界牛人就是多，所以我还是从基础开始。

豪 2005-11-27 23:12 发表评论

变量初始化的重要性!

Mon, 21 Nov 2005 16:40:00 GMT

今天在做一道华为面试题目时候，就是因为没有将变量初始化，而导致我用了一节课的时间调试：）

题目是:找出01字符串中0和1出现的最大次数.

代码：

#include<iostream>
#include<string>
using namespace std;
void main()
{
    char *a="010000010111101101000000000";
    int i,temp0=0,temp1=0,max0=0,max1=0;//对变量初始化，如果不初始化，变量值是随机的
    for(i=0;i<strlen(a);i++)
    {
        switch(a[i])
        {
            case '0':
            {
                temp0++;
                if(a[i+1]=='1'||i==strlen(a)-1)
                {
                    if(max0<temp0) max0=temp0;
                    temp0=0;
                }
                break;
            }
            case '1':
            {
                temp1++;
                if(a[i+1]=='0'||i==strlen(a)-1)
                {
                    if(max1<temp1) max1=temp1;
                    temp1=0;
                }
                break;
            }
        }
    }
    cout<<"max0="<<max0<<endl;
    cout<<"max1="<<max1<<endl;
}

那为什么不对i初始化呢？因为尽管i没被初始化，它的初始值是随机的，但在循环参数表里面已经对他进行赋值，所以i的随机值已经被0覆盖。

豪 2005-11-22 00:40 发表评论

c++之梦

Sun, 13 Nov 2005 03:08:00 GMT

奋斗c++,当你选择它的时候,别再迷茫,相信它,一定会带给你成功!!!!

豪 2005-11-13 11:08 发表评论