Question

我有使用一行while循环语句操作C-string的代码。它在使用MSVC2015编译时非常有效，但在使用TDM-GCC（gcc（tdm-1）5.1.0）编译时会产生不同的结果。

这是一个显示问题的最小示例。代码用下一个char覆盖当前char，一遍又一遍地重复，直到它将当前char设置为\0。

#include <stdio.h>

int main()
{
    char buf[999] = "Foobar", *p = buf;
    while(*p++ = *(p+1));
    printf("buf = %s\n", buf);
    return 0;
}

使用MSVC2015编译代码时，输出为buf = oobar，符合预期。但是，对于TDM-GCC，输出为buf = obar。

如果我将while语句更改为while(*p = *(p+1)) { ++p; }，则两个编译器都将给出预期结果buf = oobar。似乎通过将后增量运算符放在表达式中，我以某种方式触发了未定义的行为。

我的问题是，为什么代码在使用不同的编译器编译时表现不同？将增量运算符放在非平凡的while语句中是错误的（或非标准的）？我是否触发了未定义的行为？如果是这样，代码应如何根据C标准行事？如果没有，谁应该责怪这里？ TDM-GCC？ MSVC？

更新：对于将来与我有同样疑问的人，答案是：是的，代码调用UB。明确定义的方法是这样做：{{1} }

有人问我们为什么要像这样编码。这是一个可以使用这个习语的场景。

while(*p = *(p+1)){++p;}

Answer 1

使用-Wall如果您正在使用GCC编译器。在C＆amp; C中，这确实是一种不确定的行为。 C ++。

查看实时演示here。

参见编译器给出的诊断

main.cpp: In function 'int main()':

main.cpp:6:13: warning: operation on 'p' may be undefined [-Wsequence-point]

     while(*p++ = *(p+1));

            ~^~

Answer 2

这是未定义的行为，因为以下两个操作未被排除：

import xml.dom.minidom dom = xml.dom.minidom.parse("test.xml") data = dom.documentElement question = data.getElementsByTagName("RelQBody") i=1 for q in question: if len(q.childNodes) > 0: print("%i. %s" % (i, q.childNodes[0].data)) i = i+1

#include <stdio.h>
#include <iostream>
#include <vector>
#include <map>
#include <memory>
#include <algorithm>
namespace CORO
{
using ThreadID = unsigned;
static int thread_count;

enum STATE
{
  READY,
  ACTIVE,
  WAITING,
  ENDED
};

struct thd_data
{
  int parent_ID = 0;
  int id = 0;
  STATE state = READY;

  int * stack_mem;
  void * stackptr;
  void * stackbp;
  void*(*funcptr)(void*);
  void * param = nullptr;
  int * context_mem;
  int * context_sp;

  thd_data()
  :stack_mem{new int[1024]}, context_mem{new int[1024]} 
  {

  }

  thd_data(const thd_data & rhs)
  :stack_mem{new int[1024]}, context_mem{new int[1024]} 
  {

  }

  thd_data & operator=(const thd_data & rhs)
  {

  }
};

static thd_data* curr_thd;

std::map<int, std::shared_ptr<thd_data>> threadmap;
std::vector<int>activeListID;

// Returns a pointer to next thread
thd_data * FindNextThread()
{
  int new_id;
  for(const auto & elem : activeListID)
  {
    if(elem != curr_thd->id)
    {
      new_id = elem;
      break;
    }
  }
  auto threadmap_elem = threadmap.find(new_id);
  if(threadmap_elem != threadmap.end())
  {
    return &(*threadmap_elem->second);
  }
  else
  {
    return nullptr;
  }
}

void thd_init()
{
  threadmap[0] = std::make_shared<thd_data>();
  auto main_thd = threadmap.find(0)->second;

  main_thd->state = ACTIVE;
  main_thd->id = 0;
  main_thd->param = nullptr;
  main_thd->funcptr = nullptr;
  activeListID.push_back(main_thd->id);

  curr_thd = &(*main_thd);
}

ThreadID new_thd( void*(*func)(void*), void *param)
{
  thread_count += 1; // increment counter

  threadmap[thread_count] = std::make_shared<thd_data>();
  auto thd = threadmap.find(thread_count)->second;

  thd->state = READY;
  thd->id = thread_count;
  activeListID.push_back(thd->id);

  thd->stackptr = thd->stack_mem+1024;
  thd->stackbp = thd->stack_mem;
  thd->funcptr = func;
  thd->param = param;
  return thd->id;
}

void thd_yield()
{
  // Find the next ready thread
  thd_data* thd = FindNextThread();

  if(thd == nullptr)
    return;

  // Move ID to the end of vector
  activeListID.erase(std::remove(activeListID.begin(), activeListID.end(), curr_thd->id), activeListID.end());
  activeListID.push_back(curr_thd->id);

  // Save context
  {
    asm volatile
    (
      "movq %%rsp, %0\n\t" // save stack pointer
      "movq %%rbp, %1\n\t" // save rbp
      "movq %3, %%rsp\n\t" // point to context mem then push register values into it
      "pushq %%rax\n\t"
      "pushq %%rbx\n\t"
      "pushq %%rcx\n\t"
      "pushq %%rdx\n\t"
      "pushq %%rsi\n\t"
      "pushq %%rdi\n\t"
      "pushq %%r8\n\t"
      "pushq %%r9\n\t"
      "pushq %%r10\n\t"
      "pushq %%r11\n\t"
      "pushq %%r12\n\t"
      "pushq %%r13\n\t"
      "pushq %%r14\n\t"
      "pushq %%r15\n\t"
      "pushfq\n\t"
      "movq %%rsp, %2\n\t" // save rsp into context sp (end of context mem)
      "movq %4, %%rsp\n\t" // restore stackptr into rsp
      :"+m"(curr_thd->stackptr)   
      ,"+m"(curr_thd->stackbp)    
      ,"+m"(curr_thd->context_sp)
      :"m"(curr_thd->context_mem) 
      ,"m"(curr_thd->stackptr)    
      :"rsp"
    );
  }

  curr_thd->state = WAITING;
  curr_thd = thd;

  // Calls function if thread is not running
  if(thd->state == READY)
  {
    thd->state = ACTIVE;
    thd->funcptr(thd->param);
  }
  else
  {
    // Restore context
    {
      asm volatile
      (
        "movq %0, %%rbp\n\t" // restore stackbp into rbp
        "movq %1, %%rsp\n\t" // point to context memory to pop
        "popfq\n\t"
        "popq %%r15\n\t"
        "popq %%r14\n\t"
        "popq %%r13\n\t"
        "popq %%r12\n\t"
        "popq %%r11\n\t"
        "popq %%r10\n\t"
        "popq %%r9\n\t"
        "popq %%r8\n\t"
        "popq %%rdi\n\t"
        "popq %%rsi\n\t"
        "popq %%rdx\n\t"
        "popq %%rcx\n\t"
        "popq %%rbx\n\t"
        "popq %%rax\n\t"
        "movq %2, %%rsp\n\t" // point to TCB stack pointer
        :
        :"m"(thd->stackbp)
        ,"m"(thd->context_sp)
        ,"m"(thd->stackptr)
        :"rsp"
      );
    }
  }
}
} // end namespace
void* print1(void *a)
{
  int i;
  for(i=0; i< 20; i++)
  {
    std::cout<<"Print1 i: "<<i<<std::endl;
    if((i+1)%4==0)
        CORO::thd_yield();
  }
  return NULL;
}

void* print2(void *a)
{
  int i;
  for(i=0; i< 20; i++)
  {
    std::cout<<"Print2 i: "<<i<<std::endl;
    if((i+1)%4==0)
        CORO::thd_yield();
  }
  return NULL;
}


int main()
{
  CORO::ThreadID id;
  CORO::thd_init();
  id = CORO::new_thd(print2, NULL);
  print1(NULL);
}

阅读p

p++

Answer 3

未定义行为，因为没有定义序列点。

如果您想要一行，则解决方法为while ((*p = *(p + 1)) && p++);。

现在您将首先设置指针，如果指定的值是非零，您将继续定义到p++语句的序列。如果赋值是零，则while将结束意味着字符串被移位。

Answer 4

是的，这是未定义的行为，因为Clang编译器会出现以下错误：

source_file.cpp:6:13: warning: unsequenced modification and access to 'p' [-Wunsequenced]
    while(*p++ = *(p+1));
            ^      ~

C11：6.5表达式：

如果标量对象的副作用相对于其中任何一个都没有排序 对同一个标量对象或值有不同的副作用使用相同标量对象的值进行计算，行为是的未定义即可。如果有多个允许的排序表达式的子表达式，如果这样的话，行为是不确定的任何排序都会出现无序的副作用

是`while（* p ++ = *（p + 1））;`未定义的行为？

4 个答案: