C++学习笔记之(对象复制的困惑)

xmxoxo 2006-11-14 at XiaMen

 类的基础也学习了部份；现在正逐渐养成用类来描述程序和问题的习惯。
群里一位朋友的问题引发了类对象中的一个问题。

有一个T字型铁轨，标号为1，2，。。。，n的车厢位于铁轨的左边，
当所有车厢移动到铁轨的右边时，要求重新排序车厢的顺序。规则是支线上的
车厢可以不动，也可以移动到铁轨的右边。例如，如果n=3，车厢1，2，3在铁
轨的左边，依次进行如下的过程：3号车厢进入支线，2号车厢进入支线，2号车
厢进入铁轨的右边，3号车厢进入铁轨右边，1号车厢进入支线，1号车厢进入铁
轨右边。最后获得新的顺序1，3，2。
对于任意n值，请列出所有的可能排序。
 这应该是一道古老的题目了，记得在很久以前的某份报纸上看到这道题。
那时候还没学过数据结构，感觉可能性很难把握。使用栈结构应该是很方便描述
各种状态的。
 首先，使用单向链表来保存栈中的数据：

struct node
{
 int dat;
 node *next;
};

 

然后定义一个栈类(stack)，来描述栈对象，并将方法包装进去。
在stack类里，定义了两个private变量，m_length用来描述栈的大小；
top指针用来指向栈顶,也就是单向链表的头结点。
栈类的方法加了常用的这几个：
isempty()用来判断栈是否为空
length()用来返回栈的大小;
pop()用来出栈;
push(int)用来将数据压入栈.
同时添加了复制函数,这正是本文的重点,在下面会详细说明。

 

class stack  
{
private:
 int m_length; //栈大小
 node *top;  //头结点指针

public:
 bool push(int dat);
 int pop();
 int length();
 bool isempty();
 stack();  //构造函数
 //stack(const stack &s); //复制函数
 virtual ~stack(); //析构函数

};

 

刚开始的时候并没有给类添加复制函数，于是stack.cpp内容如下：

// Stack.cpp: implementation of the Stack class.
// 栈类，实现出栈，进栈等 
// 版本:v1.0
// 日期:2006.11.14
// 作者:xmxoxo at XiaMen
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "stack.h"
#include "stdlib.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

stack::stack()
{
 m_length = 0; //大小为0；
 top = NULL;  //初始化指针
}

stack::~stack()
{
 //terminate
 if (m_length!=0)
 {
  while (m_length>0)
  {
   pop();
  }
 }
}



//judge stack is empty
bool stack::isempty()
{
 if (top==NULL)
 {
  return 1;
 }
 else
 {
  return 0;
 }
}

//return size of stack 
int stack::length()
{
 return m_length;
}

//pop data
int stack::pop()
{
 int ret=0;
 node *tmp;
 if (m_length!=0)
 {
  //pop node
  tmp=top;
  ret=tmp->dat; 
  top = tmp->next;
  //delete node
  delete tmp;
  // size of 
  m_length--;
 }
 return ret;
}

//push data

bool stack::push(int dat)
{
 bool ret=0;
 node *tmp;
 tmp = new node;
 tmp->dat = dat;
 tmp->next = top;
 top=tmp;
 // size of stack ++
 m_length++;
 return ret;
}

描述完栈类，接下来分析题目，根据题意，左边（用stack left来表示)的火车可以进入
支线（用stack tmp来表示），也可以到右边（用stack right来表示，注意，得到的结果
就是right里保存的内容，但在输出的时候直接pop后，顺序是颠倒的），当然，如果不用
栈对象，也可以使用字串或者数组进行处理，但是表达上可能更复杂，也不太好理解。

 现在我们得到三个栈对象，left,tmp,和right,来分析一下火车的行走情况，left
出栈的火车，有两种情况，一是进入支线tmp，我们把这个行为简单记为“进”；二是直接
到右边（right)，把这个行为记为“右”；而在支线（tmp)出线的火车只有一种行为，就是
出栈后进入right，把这个行为记为“出";显然，“进”后马上“出”，就相当于“右”。
 现在先考虑1列火车的情况，根据上面的推理，1列火车时只有一种情况，就是“右”。
 再来考虑n列火车的情况，假设现在是第i列火车在left准备出栈，那么有这么几种
情况：
1、"右“。直接到right
2、“进”。根据上面的推理，“进”完后不能马上“出”了，否则就跟“右”是一样的了。
3、当tmp不为空时，left不“右”也不“进”，而是“出”,即支线火车进入右边。

枚举了所有的情况，就可以使用递归来进行编程了。递归的方法很简单，主程序如下：

'----------------------------------------------------------

// trainFoo.cpp : Defines the entry point for the console application.
//
// 火车排列问题
//作者: xmxoxo 2006.11.13 at xiamen
//当前版本 v1.0

#include "stdafx.h"
#include "stack.h"
#include "iostream.h"

//输出结果
void output(stack& p)
{
 int len,i;
 len=p.length();
 for (i=0;i<len;i++)
 {
  cout<<outtmp.pop();
  if (i!=len-1)
   cout<<",";
 }
 cout<<endl;
}

//递归过程
//参数： 左栈,临时栈,输出栈
void foo(stack left,stack tmp, stack out)
{

 int i=0;
 if (left.length()==1)
 {
  //如果左栈只有一个数,则输出这个数到输出栈
  //cout<<"右   ";
  out.push(left.pop());
  //临时栈全部出栈
  while (!tmp.isempty())
  {
   out.push(tmp.pop());
  }
  //并输出结果
  output(out);
 }
 else
 {
  //分情况

  i=left.pop();
  //cout<<"["<<i<<"]"<<"进,";
  //1.左栈进临时栈
  tmp.push(i);
  //递归,传值
  foo(left, tmp, out);

  //恢复临时栈
  i=tmp.pop();
  
  //2.左栈出栈到输出栈
  //cout<<"右,";
  out.push(i);

  //递归
  foo(left,tmp,out);

  //3.临时栈出栈到输出栈
  if (!tmp.isempty ())
  {
   out.push(tmp.pop());
   foo (left,tmp,out);
  }

 }
}

//定义左栈
stack objleft;
//定义栈
stack objstack;
//定义输出栈
stack objout;

//主程序
int main(int argc, char* argv[])
{
 int n;
 int i;
 //I/O 处理
 cout<<"Please Input Number:";
 cin>>n;

 //初始化
 //建立左栈
 for (i=1;i<=n;i++)
 {
  objleft.push (i);
 }
 
 //初始化结束

 //开始处理
 foo(objleft,objstack,objout);


 return 0;
}

'----------------------------------------------------------
程序根据N的情况进行了递归，但是运行后却发现结果不正确,经过跟踪发现
对象作为函数的参数传递的时候，传递得不正确。只有在主程序中的
foo(objleft,objstack,objout);这一句运行的时候，有正确的传递，而在
foo()函数里进行的递归调用时传递就错误了。foo函数定义的是值参，也就是
说，调用的参数会复制产生一个新的变量，在函数中使用。但是foo的三个参
数都是stack类的实例对象，在stack类中，我们定义了一个单向链表来保存栈
的数据，其中，node结构里使用到了一个指针next，正是在类中的指针导致了
对象实例在复制中的错误，在跟踪程序中发现，当递归引用foo函数时，程序
确实也复制了新的对象，连指针也复制了，但这个指针复制后，还是指向原来
的位置，而不是先复制出指针指向的空间,比如一个指针，值为0x00431D30,复制后
还是0x00431D30,还是指向同一个地址，而指向的地址并没有复制。所以无论尝试
foo(stack &left...)形参方式还是foo(stack left)值参方式，复制的新对象中
的指针仍然是指向相同的空间。
 查询了关于类的教程，原来在类里除了构造函数及析构函数，还有一个
复制函数。用于复制对象时调用，来产生新的对象，这个复制函数是在新的对象中
运行的，也就是要产生的那个对象。函数的原型是：stack::stack(const stack &s)
这里是使用形参的方式，并且使用了const前缀。根据思路，现在可以自定义出复制对象
的过程，要注意的是：在这个函数里可以访问&s这个形参的所有成员及成员函数。
（注：const前缀保证了不会对原有变量进行修改；而&s形参，则表示了引用，保证了
该函数不需要对s变量进行复制，否则，在调用复制函数时又调用复制了函数，进入了死
循环，摘自优快云）
 明白了对象的复制函数，就可以自己构造一个复制函数了，由于stack中的top指针
是头指针，在复制的过程中不能再使用push函数相同的方法来把数据加到链表顶端，而是
要加在链表的尾部，所以定义了一个临时的tail尾指针。

 

stack::stack(const stack &s)
{
 m_length = 0;
 top = NULL;
 node *tmp;
 node *tail; //尾指针
 node *newnode;
 tmp=s.top;
 tail=NULL;
 while (tmp!=NULL)
 {

  newnode = new node;
  newnode->dat = tmp->dat;
  newnode->next =NULL;
  if (top!=NULL)
  {
   tail->next =newnode;
   tail=newnode;
  }
  else
  {
   top=newnode;
   tail=newnode;
  }
  // size of stack ++
  m_length++;

  tmp=tmp->next;
 }
}

加入了复制函数后，stack类可以正常工作了，主程序不需要修改。
以下是n=3及n=4的输出结果：

Please Input Number:3
3,2,1
3,1,2
1,3,2
2,1,3
1,2,3
Press any key to continue

Please Input Number:4
4,3,2,1
4,3,1,2
4,1,3,2
4,2,1,3
4,1,2,3
1,4,2,3
2,1,4,3
1,2,4,3
3,2,1,4
3,1,2,4
1,3,2,4
2,1,3,4
1,2,3,4
Press any key to continue

可以看出，输出的结果很有规律，正是按上面我们分析的“进”，“右”，“出”方式得到的结果。 

11.17 补记:

    上面的主程序在情况分析有误，情况1和情况2会出现重复，可以合并处理，另外，原先是判断n=1
时输出结果，也可以直接合并到递归里，判断左堆栈和临时栈同时为空即可输出结果。修改后得到了
以下的程序及结果：

// trainFoo.cpp : Defines the entry point for the console application.
//
// 火车排列问题
//作者: xmxoxo 2006.11.13 at xiamen
//当前版本 v1.0

#include "stdafx.h"
#include "stack.h"
#include "iostream.h"

//输出结果
void output(stack p)
{
    int len,i;
    len=p.length();
    for (i=0;i<len;i++)
    {
        cout<<p.pop();
        if (i!=len-1)
            cout<<",";
    }
    cout<<endl;
}

//递归过程
//参数： 左栈,临时栈,输出栈
int foo(stack left,stack tmp, stack out)
{
    static count;
    int i=0;
    //分情况

    //1.左栈进临时栈
    if (!left.isempty())
    {
        tmp.push(left.pop());
        //cout<<"进,";
        //递归,传值
        foo(left, tmp, out);
        //恢复左栈
        left.push(tmp.pop());
    }
    //2.临时栈出栈到输出栈
    if (!tmp.isempty())
    {
        //cout<<"出,";
        out.push(tmp.pop());
        foo (left,tmp,out);
        //恢复状态
        tmp.push (out.pop());
    }
    if (left.isempty()&&tmp.isempty())
    {
        output(out);
        count++;
    }
    return count;
}

//定义栈
stack objstack;
//定义左栈
stack objleft;
//定义输出栈
stack objout;

//主程序
int main(int argc, char* argv[])
{
    int n;
    int i;
    int count=0;
    //I/O 处理
    cout<<"Please Input Number:";
    cin>>n;

    //初始化
    //建立左栈
    for (i=1;i<=n;i++)
    {
        objleft.push (i);
    }
    
    //初始化结束
    
    //开始处理
    count=foo(objleft,objstack,objout);
    cout << "共 " << count << "个结果."<<endl;
    return 0;
}

Please Input Number:3
3,2,1
3,1,2
1,3,2
2,1,3
1,2,3
共 5个结果.

Please Input Number:4
4,3,2,1
4,3,1,2
4,1,3,2
1,4,3,2
4,2,1,3
4,1,2,3
1,4,2,3
2,1,4,3
1,2,4,3
3,2,1,4
3,1,2,4
1,3,2,4
2,1,3,4
1,2,3,4
共 14个结果.