计算一个字符串

于 2007-05-19 21:35:00 发布
阅读量683 收藏
点赞数
分类专栏： 算法专栏 文章标签： float string iostream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujiwei2007/article/details/1616873
版权

 

 


/**************************************************
* 文 件 名：  Compute_string.cpp
* 文件描述：  计算一个字符串的实现文件
* 创 建 人：  刘基伟
* 创建日期：  2007年　5月　19日
* 版 本 号：  1.0
* 修改纪录：  暂无
*************************************************/


                /**************************************************
              *                                                 *
              *                   加载头文件                    *
             *                                                 *
              ***************************************************/
#include <iostream>

using namespace std;

                /**************************************************
              *                                                 *
              *                   预处理命令                    *
             *                                                 *
              ***************************************************/

#define     LOW         0
#define     HIGH        1
#define     MULTIPLY    42
#define     PLUS        43
#define     SUBTRACT    45
#define     DIVIDE      47

 


/*=======================================================
* 函 数 名：　String_to_float(char *const, int )
* 参数说明：  pString 为传入的数组
              iCount 为数组的个数
* 功能描述：  当一个字符串的符号大于等于三个时
              计算一个字符串里面的值
              字符串里面仅含有数值和 +*-/ 四个符号
* 返 回 值：  float
=======================================================*/

float String_to_float(char *const pString, int iCount)
{
 /**************************************************
 *                                                 *
 *                   变量声明                      *
 *                                                 *
 ***************************************************/

 float iFirst_value;       // 第一操作数
 float iSecond_value;      // 第二操作数
 float iThird_value;       // 第三操作数
 int   iFirst_opt_flag;    // 第一操作符的优先级
 int   iSecond_opt_flag;   // 第二操作符的优先级
 char  chFirst_opt;        // 第一操作符
 char  chSecond_opt;       // 第二操作符
 char  chThird_opt;        // 第三操作符
 char  *pCurrent;          // 字符串当前指针
 char  *pBegin;            // 字符串的开始位置
 char  *pEnd;              // 字符串的结束位置
 char  *pFirst_opt;        // 第一操作数开始位置
 char  *pSecond_opt;       // 第二操作数开始位置
 char  *pThird_opt;        // 第三操作数开始位置
 char  *pFirst_value;      // 第一操作符开始位置
 char  *pSecond_value;     // 第二操作符开始位置
 char  *pThird_value;      // 第三操作符开始位置
 
    /**************************************************
 *                                                 *
 *                   变量初始化                    *
 *                                                 *
 ***************************************************/
 
 pCurrent      = pString;
 pBegin        = pString - 1;
 pEnd          = pString + iCount - 1;
 pFirst_opt    = pString;
 pSecond_opt   = pString;
 pThird_opt    = pString;
 pFirst_value  = pString;
 pSecond_value = pString;
 pThird_value  = pString;

   /**************************************************
 *                                                 *
 *          计算第一操作数和第一操作符及其优先级   *
 *                                                 *
 ***************************************************/

    iFirst_value = atoi(pFirst_opt);            // 计算第一个操作数
 while((*pFirst_value >= '0') && (*pFirst_value <= '9') && (pFirst_value != pEnd))
 {
  pFirst_value++;
 }
 pFirst_opt  = pFirst_value;                 // 找到第一操作符的位置
 chFirst_opt = *pFirst_opt;                  // 计算第一个操作符
 if((chFirst_opt == '+') || (chFirst_opt == '-'))   // 计算第一操作符的优先级
 {
  iFirst_opt_flag = LOW;
 }
 else
 {
  iFirst_opt_flag = HIGH;
 }

 /**************************************************
 *                                                 *
 *        计算第二操作数和第二操作符及其优先级     *
 *                                                 *
 ***************************************************/

 pSecond_value = pFirst_opt + 1;      
 iSecond_value = atoi(pSecond_value);        // 计算第二个操作数
    while((*pSecond_value >= '0') && (*pSecond_value <= '9') && (pSecond_value != pEnd))
    {
  pSecond_value++;
 }
 pSecond_opt  = pSecond_value;               // 找到第二个操作符的位置
    chSecond_opt = *pSecond_opt;                // 计算第二个操作符
 if((chSecond_opt == '+') || (chSecond_opt == '-'))   // 计算第二操作符的优先级
 {
  iSecond_opt_flag = LOW;
 }
 else
 {
  iSecond_opt_flag = HIGH;
 }

 /**************************************************
 *                                                 *
 *               计算第三操作数和第三操作符        *
 *                                                 *
 ***************************************************/

 pThird_value = pSecond_opt + 1;            
 iThird_value = atoi(pThird_value);          // 计算第三个操作数
    while((*pThird_value >= '0') && (*pThird_value <= '9') && (pThird_value != pEnd))
    {
  pThird_value++;
 }
 pThird_opt  = pThird_value;                 // 找到第三个操作符的位置
 chThird_opt = *pThird_opt;                  // 计算第三个操作符

 /**************************************************
 *                                                 *
 *           进入循环体，一直处理到最后            *
 *                                                 *
 ***************************************************/

 while( true )
 {
  /**************************************************
     *                                                 *
     *  比较第一操作符和第二操作符， 再分别进行处理    *
     *                                                 *
     ***************************************************/

  if(iFirst_opt_flag >= iSecond_opt_flag)      // 第一操作符的优先级大于等于第二操作符
  {
   switch((int)chFirst_opt)                 // 计算第一操作数
   {
   case MULTIPLY:                           // 第一操作符为 *
    iFirst_value *= iSecond_value;
    break;
   case PLUS:                               // 第一操作符为 +
    iFirst_value += iSecond_value;
    break;
   case SUBTRACT:                           // 第一操作符为 -
    iFirst_value -= iSecond_value;
    break;
   case DIVIDE:                             // 第一操作符为 /
    iFirst_value /= iSecond_value;
    break;
   default:
    break;
   }

   /**************************************************
   *                                                 *
   *                   变量重置                      *
   *                                                 *
   ***************************************************/

   iSecond_value = iThird_value;           // 重新设定第二操作数
   pFirst_opt    = pSecond_opt;            // 重新设定第一操作符的位置
   pSecond_opt   = pThird_opt;             // 重新设定第二操作符的位置
   chFirst_opt   = *pFirst_opt;            // 重新设定第一操作符
   chSecond_opt  = *pSecond_opt;           // 重新设定第二操作符
   if((chFirst_opt == '+') || (chFirst_opt == '-'))   // 重新计算第一操作符的优先级
   {
    iFirst_opt_flag = LOW;
   }
   else
   {
    iFirst_opt_flag = HIGH;
   }
   if((chSecond_opt == '+') || (chSecond_opt == '-')) // 重新计算第二操作符的优先级
   {
    iSecond_opt_flag = LOW;
   }
   else
   {
    iSecond_opt_flag = HIGH;
   }
  }
  else                     //第一操作符的优先级小于第二操作符
  {
   switch((int)chSecond_opt)                     // 计算第二操作数
   {
   case MULTIPLY:                                // 第二操作符为 *
    iSecond_value *= iThird_value;
    break;
   case DIVIDE:                                  // 第二操作符为 /
    iSecond_value /= iThird_value;
    break;
   default:
    break;
   }
   /**************************************************
   *                                                 *
   *                   变量重置                      *
   *                                                 *
   ***************************************************/
   pSecond_opt  = pThird_opt;                         // 重新设定第二操作符
   chSecond_opt = *pSecond_opt;
   if((chFirst_opt == '+') || (chFirst_opt == '-'))   // 计算第一操作符的优先级
   {
    iFirst_opt_flag = LOW;
   }
   else
   {
    iFirst_opt_flag = HIGH;
   }
   if((chSecond_opt == '+') || (chSecond_opt == '-')) // 计算第二操作符的优先级
   {
    iSecond_opt_flag = LOW;
   }
   else
   {
    iSecond_opt_flag = HIGH;
   }
  }
       /**************************************************
         *                                                 *
          *      计算第三操作数和第三操作符                 *
         *                                                 *
         ***************************************************/

  pThird_value = pThird_opt + 1;            
  iThird_value = atoi(pThird_value);      // 计算第三个操作数
  while((*pThird_value >= '0') && (*pThird_value <= '9') )
  {
   pThird_value++;
  }
      /**************************************************
         *                                                 *
          *      到了末尾，处理函数然后退出                 *
         *                                                 *
         ***************************************************/

  if(pThird_value == pEnd)              
  {
   if(iFirst_opt_flag >= iSecond_opt_flag)    //第一操作符的优先级大于等于第二操作符
   {
    switch((int)chFirst_opt)               // 计算第一操作数
    {
    case MULTIPLY:
     iFirst_value *= iSecond_value;
     break;
    case PLUS:
     iFirst_value += iSecond_value;
     break;
    case SUBTRACT:
     iFirst_value -= iSecond_value;
     break;
    case DIVIDE:
     iFirst_value /= iSecond_value;
     break;
    default:
     break;
    }
    switch((int)chSecond_opt)               // 计算第二操作数
    {
    case MULTIPLY:
     iFirst_value *= iThird_value;
     break;
    case PLUS:
     iFirst_value += iThird_value;
     break;
    case SUBTRACT:
     iFirst_value -= iThird_value;
     break;
    case DIVIDE:
     iFirst_value /= iThird_value;
     break;
    default:
     break;
    }
   }
   else                   //第一操作符的优先级小于第二操作符           
   {
    switch((int)chSecond_opt)               // 计算第二操作数
    {
    case MULTIPLY:
     iSecond_value *= iThird_value;
     break;
    case DIVIDE:
     iSecond_value /= iThird_value;
     break;
    default:
     break;
    }
    switch((int)chFirst_opt)               // 计算第一操作数
    {
    case MULTIPLY:
     iFirst_value *= iSecond_value;
     break;
    case PLUS:
     iFirst_value += iSecond_value;
     break;
    case SUBTRACT:
     iFirst_value -= iSecond_value;
     break;
    case DIVIDE:
     iFirst_value /= iSecond_value;
     break;
    default:
     break;
    }
   }
   return iFirst_value; 
  }

   /**************************************************
         *                                                 *
          *     没有结束，计算第三操作符,                   *  
         *                                                 *
         ***************************************************/

  else                      
  {
   pThird_opt  = pThird_value;     // 找到第三个操作符的位置
   chThird_opt = *pThird_opt;      // 计算第三个操作符
  }
 }
}

/*=======================================================
* 函 数 名：　Compute_string(char *const, int )
* 参数说明：  pString 为传入的数组
              iCount 为数组的个数
* 功能描述：  计算一个字符串里面的值
              字符串里面仅含有数值和 +*-/ 四个符号
* 返 回 值：  float
=======================================================*/

float Compute_string(char *const pString,int iCount)
{
 float iFirst_value;       // 第一操作数
 float iSecond_value;      // 第二操作数
 float iThird_value;       // 第三操作数
 int   iFirst_opt_flag;    // 第一操作符的优先级
 int   iSecond_opt_flag;   // 第二操作符的优先级
 char  chFirst_opt;        // 第一操作符
 char  chSecond_opt;       // 第二操作符
 char  *pFirst_opt;        // 第一操作数开始位置
 char  *pSecond_opt;       // 第二操作数开始位置
 char  *pThird_opt;        // 第三操作数开始位置
 char  *pFirst_value;      // 第一操作符开始位置
 char  *pSecond_value;     // 第二操作符开始位置
 char  *pThird_value;      // 第三操作符开始位置

 pFirst_opt    = pString;
 pSecond_opt   = pString;
 pThird_opt    = pString;
 pFirst_value  = pString;
 pSecond_value = pString;
 pThird_value  = pString;
 char *pBegin   = pString;
 char *pCurrent = pString;
 char *pEnd     = pCurrent + iCount - 1;
 int  iOperator_count = 0;
 float fReturn_value = 0.0;

 while(pCurrent != pEnd)
  {
   if((*pCurrent < '0') || (*pCurrent > '9'))
   {
    iOperator_count++;
   }
   pCurrent++;
  }

    switch(iOperator_count)
 {
 case 0:              // 没有操作符
  fReturn_value = atoi(pBegin);
  break;
 case 1:                                // 一个操作符
  iFirst_value = atoi(pFirst_opt);            // 计算第一个操作数
  while((*pFirst_value >= '0') && (*pFirst_value <= '9') && (pFirst_value != pEnd))
  {
   pFirst_value++;
  }
  pFirst_opt  = pFirst_value;                 // 找到第一操作符的位置
  chFirst_opt = *pFirst_opt;                  // 计算第一个操作符
  if((chFirst_opt == '+') || (chFirst_opt == '-'))   // 计算第一操作符的优先级
  {
   iFirst_opt_flag = LOW;
  }
  else
  {
   iFirst_opt_flag = HIGH;
  }
  pSecond_value = pFirst_opt + 1;      
  iSecond_value = atoi(pSecond_value);        // 计算第二个操作数
  switch(chFirst_opt)
  {
  case MULTIPLY:                               // 第一操作符为 *
   fReturn_value = iFirst_value * iSecond_value;
   break;
  case PLUS:                               // 第一操作符为 +
   fReturn_value = iFirst_value + iSecond_value;
   break;
  case SUBTRACT:                               // 第一操作符为 -
   fReturn_value = iFirst_value - iSecond_value;
   break;
  case DIVIDE:                               // 第一操作符为 /
   fReturn_value = iFirst_value / iSecond_value;
   break;
  default:
   break;
  }
  break;
 case 2:                               // 两个操作符
  iFirst_value = atoi(pFirst_opt);            // 计算第一个操作数
  while((*pFirst_value >= '0') && (*pFirst_value <= '9') && (pFirst_value != pEnd))
  {
   pFirst_value++;
  }
  pFirst_opt  = pFirst_value;                 // 找到第一操作符的位置
  chFirst_opt = *pFirst_opt;                  // 计算第一个操作符
  if((chFirst_opt == '+') || (chFirst_opt == '-'))   // 计算第一操作符的优先级
  {
   iFirst_opt_flag = LOW;
  }
  else
  {
   iFirst_opt_flag = HIGH;
  }
  pSecond_value = pFirst_opt + 1;      
  iSecond_value = atoi(pSecond_value);        // 计算第二个操作数
  while((*pSecond_value >= '0') && (*pSecond_value <= '9') && (pSecond_value != pEnd))
  {
   pSecond_value++;
  }
  pSecond_opt  = pSecond_value;               // 找到第二个操作符的位置
  chSecond_opt = *pSecond_opt;                // 计算第二个操作符
  if((chSecond_opt == '+') || (chSecond_opt == '-'))   // 计算第二操作符的优先级
  {
   iSecond_opt_flag = LOW;
  }
  else
  {
   iSecond_opt_flag = HIGH;
  }
  pThird_value = pSecond_opt + 1;            
  iThird_value = atoi(pThird_value);          // 计算第三个操作数
  if(iFirst_opt_flag >= iSecond_opt_flag)  //第一操作符的优先级大于等于第二操作符
  {
   switch((int)chFirst_opt)               // 计算第一操作数
   {
   case MULTIPLY:
       iFirst_value *= iSecond_value;
    break;
   case PLUS:
    iFirst_value += iSecond_value;
    break;
   case SUBTRACT:
    iFirst_value -= iSecond_value;
    break;
   case DIVIDE:
    iFirst_value /= iSecond_value;
    break;
   default:
    break;
   }
   switch((int)chSecond_opt)               // 计算第二操作数
   {
   case MULTIPLY:
    iFirst_value *= iThird_value;
    break;
   case PLUS:
    iFirst_value += iThird_value;
    break;
   case SUBTRACT:
    iFirst_value -= iThird_value;
    break;
   case DIVIDE:
    iFirst_value /= iThird_value;
    break;
   default:
    break;
   }
  }
  else                   //第一操作符的优先级小于第二操作符           
  {
   switch((int)chSecond_opt)               // 计算第二操作数
   {
   case MULTIPLY:
    iSecond_value *= iThird_value;
    break;
   case DIVIDE:
    iSecond_value /= iThird_value;
    break;
   default:
    break;
   }
   switch((int)chFirst_opt)               // 计算第一操作数
   {
   case MULTIPLY:
    iFirst_value *= iSecond_value;
    break;
   case PLUS:
    iFirst_value += iSecond_value;
    break;
   case SUBTRACT:
    iFirst_value -= iSecond_value;
    break;
   case DIVIDE:
          iFirst_value /= iSecond_value;
    break;
   default:
    break;
   }
  } 
  fReturn_value = iFirst_value;
  break;
 case 3:               // 三个或者三个以上操作符
 default:
  fReturn_value = String_to_float(pString,iCount);
        break;
 }
 return fReturn_value;
}

 

 

int main()
{
    char pString[] = "1+5*8";
 float i = Compute_string(pString, sizeof(pString));
 cout<<i<<endl;
 return 0;
}

 

liujiwei2007
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值