strrev.cpp

编写反转字符串的程序

// strrev.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <string.h>


 /************************************************************************/   
  //   函数名称:   Ustrlen   
  //   输入参数:   strSource,待求长度字符串；   
  //   输出参数:   int，字符串的长度。   
  //   描         述:   通过判断字符'\0'来得到字符串的长度   
  /************************************************************************/     
  int   Ustrlen(const   char   *strSource)   
  {   
            //   声明变量   
            int   iLength(0);   
            //   遍历字符串，查找字符'\0'   
            while(*strSource++   !=   '\0')   
            {   
                    ++iLength;   
            }   
            //   返回字符串的长度   
            return   iLength;   
  }   
  /************************************************************************/   
  //   函数名称:   _ReversalChar   
  //   输入参数:   strSouce，待反转字符串；iStart，旋转字符串开始位置；iEnd，旋转字符串结束位置   
  //   输出参数:   char*，反转后字符串的指针；   
  //   描         述:   反转iStart到字符串iEnd之间的字符串   
  /************************************************************************/   
  char*   _ReversalChar(char   *strSouce,int   iStart,int   iEnd)   
  {   
            //   反转字符串   
            for(;iEnd   >   iStart;   ++iStart,--iEnd)   
            {   
                    char   ch;   
                    ch   =   strSouce[iStart];   
                    strSouce[iStart]   =   strSouce[iEnd];   
                    strSouce[iEnd]   =   ch;   
            }   
            //   返回字符串指针   
            return   strSouce;   
  }   
      
  /************************************************************************/   
  //   函数名称:   ReversalChar   
  //   输入参数:   strSource，待反转字符串   
  //   输出参数:   char*，反转字符串后的指针   
  //   描         述:   按单词反转字符串   
  /************************************************************************/   
  char   *   ReversalChar(char   *strSouce)   
  {   
            //   获取字符串的长度   
            int   iLength   =   Ustrlen(strSouce);   
      
            //   反转整个字符串   
            _ReversalChar(strSouce,0,iLength-1);   
      
            //   声明变量（单词的开始以及结束默认从0开始）   
            int   iStart(0),iEnd(0);   
      
            //   查找单词   
            //   像上面讨论的查找单词的情况，我们只需要修改这部分，就可以实现对不   
            //   同格式类型单词进行处理，为了更好的通用性，其实最好把查找单词这部分   
            //   作为单独一个函数，或者一个类来处理   
            for(int   i   =   0;   i   <   iLength;   ++i)   
            {   
                    //   查找空格分割符号   
                    if(strSouce[i]   ==   ' ')   
                    {   
                              //   找到一个单词   
                              iEnd   =   i-1;   
                              //   对于只有一个字符的单词比如说（I）没有必要反转   
                              if(iStart   <   iEnd)   
                              {   
                                        //   反转单词   
                                        _ReversalChar(strSouce,iStart,iEnd);   
                              }   
                              //   记录下一个单词的开始位置   
                              iStart   =   i+1;   
                    }   
                    //   特殊处理几种常见标点符号   
                    else   if(strSouce[i]   ==   '!'   ||   strSouce[i]   ==   ','   ||   strSouce[i]   ==   '.')   
                    {   
                              iStart   =   i+1;   
                    }   
            }   
            //   返回反转后的字符串   
            return   strSouce;   
  }   

void   RevStr(char src[])   
{   
   char  *start=src,  *end=src, *p=src;   
   int   i=0;   
   do   
   {   
       if(*p==' '|| *p==','|| *p=='.'|| *p==';'|| *p=='!' || *p=='\0' )   
       {   
          i=1;
		  end=p-1;
          while(start<end)
		  {
			  
			  *end ^= *start;
			  *start ^= *end;
			  *end ^= *start;

              --end;
              ++start;
		  }
       }   

       if(i)
	   {
		   start=p+1;
		   i=0;
	   }
   }while(*p++);   
    
   while(src<end)
   {
	   *end ^= *src;
	   *src ^= *end;
	   *end ^= *src;

       --end;
       ++src;
   }
}   

void arrayrev(int &ar)
{
	int *p = (int*)&ar;
    int *q = (int*)(&ar + 8 - 1);

    while (q > p)
    {
         *q ^= *p;
         *p ^= *q;              
         *q ^= *p;

         --q;
         ++p;
    }
}

void strrev3(char* str)
{
    char* p = str + strlen(str) - 1;

    while (p > str)
    {
         *p ^= *str;
         *str ^= *p;              
         *p ^= *str;

         --p;
         ++str;
    }
}

int main(int argc, char* argv[])
{
    char   ch[]   ="I   am   a   student !!"; 
	ReversalChar(ch);
	printf("%s\n", ch);

    char   src[]="thank you, my friend!!!";   
    printf("%s\n",src);   
    RevStr(src);   
    printf("%s\n",src);   
    strrev3(src);   
    printf("%s\n",src);   

    int a[8]={101,102,103,104,105,106,107,108}; 
    int *ptr1=(int*)(&a+1); 
    int *ptr2=(int*)((int)a+1); 
    printf("%d %x, %d %x\n", ptr1[-1], ptr1[-1], *ptr2, *ptr2); 
	arrayrev(a[0]);

	for(int i=0; i<8; i++)
		printf("%d ", a[i]);

	return 0;
}

/*
&a   取得地址以后加一的操作，指针增加了sizeof(a)这么多的绝对地址。这应该是指针加了20，然后一个-1有减去了4，这样相当于指针的绝对地址加了16，指向的 

就是a[4]的首地址。 

第二个就是将指针的绝对地址，数值加一的操作，然后按照内存的排布，得出来的。
a 的内存存放
地址： 00 01 02 03 04 05 06 07 
数据： 01 00 00 00 02 00 00 00
a = 00;
ptr2 = (int*)((int)a + 1);
ptr2 = 01;
所以ptr2指向的内存为
地址： 01 02 03 04
数据： 00 00 00 02
即*ptr2 = 0x2000000;
这是little-endian情况下。

如果是big-endian，结果不一样。
a 的内存存放
地址： 00 01 02 03 04 05 06 07 
数据： 00 00 00 01 00 00 00 02
ptr2指向的内存为
地址： 01 02 03 04
数据： 00 00 01 00
*ptr2 = 0x100;

#include   <stdio.h> 
int   main(void) 
{ 
    int   a[5]={1,2,3,4,5};
    //假设a的地址为0x80000000，sizeof(int)=4
    //假设是little-endian，则0x80000000-0x80000013的数据为：
    // addr: 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13
    // data: 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
    int   *ptr1=(int   *)(&a+1); //ptr1 = 0x80000000+20=0x80000014
    int   *ptr2=(int   *)((int   )a+1); //ptr2 = 0x80000000+1 = 0x80000001
    //&ptr1[-1] = 0x80000014-4 = 0x80000010,so ptr1[-1] = *(int *)0x80000010 = 5
    //*ptr2 = *(int *)0x80000001 = 0x02000000
    printf("%x,%x",ptr1[-1],*ptr2); 
    return   0; 
} 

*/