C++11 无法编译简单的C++；程序 我遵循了C++教程，当我试图编译第二个练习时，我得到了这个令人敬畏的结果：

这是一个永无止境的代码滚动，没有其他事情发生。 我用于编译的代码是：

cpp Small.cpp

…文件的代码为：

#include <iostream>

int main(){
    std::cout << "Hello!" << std::endl << 2+2;
    return 0;
}

#包括
int main（）{
标准：：cout:：u值，void>：：u类型
__填写a（\u ForwardIterator\u首先，\u ForwardIterator\u最后，
常数（Tp和值）
{
常数Tp uu tmp=u值；
对于（；\uuuu first！=\uuuu last；++\uuu first）
*__第一个=tmp；
}
模板
内联类型名
__gnu_cxx:：_启用_如果：：_类型
__填充a（\u Tp*\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
{
常数Tp(tmp)=(c)；
__内置内存集（uuu优先，静态模式（uuu tmp），
__最后-第一次）；
}
#719“c:\\tdm-gcc-32\\lib\\gcc\\mingw32\\4.8.1\\include\\c++\\bits\\stl\u algoba
e、 h“3
模板
内联空隙
填充（_ForwardIterator uu first，_ForwardIterator uu last，const _Tp&u value）
{
;
std:：uuu填充a（std:uuu niter_ubase（uuu first），std:uu niter_ubase（uu last），
__价值）；
}
模板
内联类型名
__gnu_cxx:：：_启用_如果：：_值，_输出计算器>：：_类型
__填充a（\u输出计算器\u第一，\u大小\u n，常数\u Tp和\u值）
{
对于（uuu decltype（uuu n+0）uuu niter=uuu n；
__niter>0；————————————————————————————————————————————————————————————————————
*__第一个=_值；
首先返回；
}
模板
内联类型名
__gnu_cxx:：_启用_如果：：_类型
__填充a（\u输出计算器\u第一，\u大小\u n，常数\u Tp和\u值）
{
常数Tp uu tmp=u值；
对于（uuu decltype（uuu n+0）uuu niter=uuu n；
__niter>0；————————————————————————————————————————————————————————————————————
*__第一个=tmp；
首先返回；
}
模板
内联类型名
__gnu_cxx:：_启用_如果：：_类型
__填充a（\u Tp*\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
{
标准：：uuu fill_ua（uuu first，uuu first+uu n，uu c）；
返回\uuuu first+\uuu n；
}
#779“c:\\tdm-gcc-32\\lib\\gcc\\mingw32\\4.8.1\\include\\c++\\bits\\stl\u algoba
e、 h“3
模板
内联
填充（\u OI\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
{
返回值(标准:):(标准:)填充(标准:)单位(基数),单位,单位值);；
}
模板
结构等于
{
模板
静态布尔
相等（_II1 uu first1，_II1 u last1，_II2 u first2）
{
对于（；uuu first1！=uu last1；++uu first1，++u first2）
如果（！（*\uu first1==*\uu first2））
返回false；
返回true；
}
};
模板
结构等于
{
模板
静态布尔
相等（常数Tp*\uuu first1，常数Tp*\uu last1，常数Tp*\uu first2）
{
return！\uuuuu内置\u memcmp（\uuuuu first1，\uuuuu first2，sizeof（\u Tp）
*（uu last1-u first1））；
}
};
模板
内联布尔
__相等的辅助（II1 uuuu first1，II1 uuu last1，II2 uu first2）
{
typedef typename迭代器_traits:：value_type_ValueType1；
typedef typename迭代器_traits:：value_type_ValueType2；
const bool_uuusimple=（uuu是_整数：：u值
||_uu是_指针：：u值）
&&_uu是_指针：：u值
&&_uu是_指针：：u值
&&_uu相同：：u值）；
返回std:：uuu equal：：equal（uuu first1，uuu last1，uuu first2）；
}
模板
结构
{
模板
静态
__新的last1（_II1，_II1，_last1，_II2，_II2）
{return\uu last1；}
模板
静态布尔
__cnd2（第一，最后）
{返回{uuu first！={uu last；}
};
模板
结构
{
模板
静态
__新的last1（\u RAI1\u first1，\u RAI1\u last1，
_RAI2（第一个2，最后一个2）
{
常量类型名迭代器特征：：差异类型
__diff1=\uuuu last1-\uuuu first1；
常量类型名迭代器特征：：差异类型
__diff2=\uuuuu last2-\uuuuuu first2；
返回uuu diff2    {
      template<typename _Tp>
        static _Tp*
        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
   const ptrdiff_t _Num = __last - __first;
   if (_Num)
     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
   return __result - _Num;
 }
    };

  template<bool _IsMove, typename _BI1, typename _BI2>
    inline _BI2
    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
      typedef typename iterator_traits<_BI1>::iterator_category _Category;
      const bool __simple = (__is_trivial(_ValueType1)
                      && __is_pointer<_BI1>::__value
                      && __is_pointer<_BI2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__copy_move_backward<_IsMove, __simple,
                                _Category>::__copy_move_b(__first,
         __last,
         __result);
    }

  template<bool _IsMove, typename _BI1, typename _BI2>
    inline _BI2
    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      return _BI2(std::__copy_move_backward_a<_IsMove>
    (std::__niter_base(__first), std::__niter_base(__last),
     std::__niter_base(__result)));
    }
# 617 "c:\\tdm-gcc-32\\lib\\gcc\\mingw32\\4.8.1\\include\\c++\\bits\\stl_algoba
e.h" 3
  template<typename _BI1, typename _BI2>
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {






      ;

      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
       (std::__miter_base(__first), std::__miter_base(__last),
        __result));
    }
# 675 "c:\\tdm-gcc-32\\lib\\gcc\\mingw32\\4.8.1\\include\\c++\\bits\\stl_algoba
e.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __value)
    {
      for (; __first != __last; ++__first)
 *__first = __value;
    }

  template<typename _ForwardIterator, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __first != __last; ++__first)
 *__first = __tmp;
    }


  template<typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
    {
      const _Tp __tmp = __c;
      __builtin_memset(__first, static_cast<unsigned char>(__tmp),
         __last - __first);
    }
# 719 "c:\\tdm-gcc-32\\lib\\gcc\\mingw32\\4.8.1\\include\\c++\\bits\\stl_algoba
e.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {



      ;

      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
      __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      for (__decltype(__n + 0) __niter = __n;
    __niter > 0; --__niter, ++__first)
 *__first = __value;
      return __first;
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (__decltype(__n + 0) __niter = __n;
    __niter > 0; --__niter, ++__first)
 *__first = __tmp;
      return __first;
    }

  template<typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
    {
      std::__fill_a(__first, __first + __n, __c);
      return __first + __n;
    }
# 779 "c:\\tdm-gcc-32\\lib\\gcc\\mingw32\\4.8.1\\include\\c++\\bits\\stl_algoba
e.h" 3
  template<typename _OI, typename _Size, typename _Tp>
    inline _OI
    fill_n(_OI __first, _Size __n, const _Tp& __value)
    {



      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
    }

  template<bool _BoolType>
    struct __equal
    {
      template<typename _II1, typename _II2>
        static bool
        equal(_II1 __first1, _II1 __last1, _II2 __first2)
        {
   for (; __first1 != __last1; ++__first1, ++__first2)
     if (!(*__first1 == *__first2))
       return false;
   return true;
 }
    };

  template<>
    struct __equal<true>
    {
      template<typename _Tp>
        static bool
        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
        {
   return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
       * (__last1 - __first1));
 }
    };

  template<typename _II1, typename _II2>
    inline bool
    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple = ((__is_integer<_ValueType1>::__value
         || __is_pointer<_ValueType1>::__value)
                      && __is_pointer<_II1>::__value
                      && __is_pointer<_II2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__equal<__simple>::equal(__first1, __last1, __first2);
    }


  template<typename, typename>
    struct __lc_rai
    {
      template<typename _II1, typename _II2>
        static _II1
        __newlast1(_II1, _II1 __last1, _II2, _II2)
        { return __last1; }

      template<typename _II>
        static bool
        __cnd2(_II __first, _II __last)
        { return __first != __last; }
    };

  template<>
    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
    {
      template<typename _RAI1, typename _RAI2>
        static _RAI1
        __newlast1(_RAI1 __first1, _RAI1 __last1,
     _RAI2 __first2, _RAI2 __last2)
        {
   const typename iterator_traits<_RAI1>::difference_type
     __diff1 = __last1 - __first1;
   const typename iterator_traits<_RAI2>::difference_type
     __diff2 = __last2 - __first2;
   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
 }

      template<typename _RAI>
        static bool
        __cnd2(_RAI, _RAI)
        { return true; }
    };

  template<bool _BoolType>
    struct __lexicographical_compare
    {
      template<typename _II1, typename _II2>
        static bool __lc(_II1, _II1, _II2, _II2);
    };

  template<bool _BoolType>
    template<typename _II1, typename _II2>
      bool
      __lexicographical_compare<_BoolType>::
      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
      {
 typedef typename iterator_traits<_II1>::iterator_category _Category1;
 typedef typename iterator_traits<_II2>::iterator_category _Category2;
 typedef std::__lc_rai<_Category1, _Category2> __rai_type;

 __last1 = __rai_type::__newlast1(__first1, __last1,
      __first2, __last2);
 for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
      ++__first1, ++__first2)
   {
     if (*__first1 < *__first2)
       return true;
     if (*__first2 < *__first1)
       return false;
   }
 return __first1 == __last1 && __first2 != __last2;
      }

  template<>
    struct __lexicographical_compare<true>
    {
      template<typename _Tp, typename _Up>
        static bool
        __lc(const _Tp* __first1, const _Tp* __last1,
      const _Up* __first2, const _Up* __last2)
 {
   const size_t __len1 = __last1 - __first1;
   const size_t __len2 = __last2 - __first2;
   const int __result = __builtin_memcmp(__first1, __first2,
      std::min(__len1, __len2));
   return __result != 0 ? __result < 0 : __len1 < __len2;
 }
    };

  template<typename _II1, typename _II2>
    inline bool
    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
      _II2 __first2, _II2 __last2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple =
 (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
  && __is_pointer<_II1>::__value
  && __is_pointer<_II2>::__value);

      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
           __first2, __last2);
    }
# 941 "c:\\tdm-gcc-32\\lib\\gcc\\mingw32\\4.8.1\\include\\c++\\bits\\stl_algoba
e.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {




      typedef t