Question

我使用以下正则表达式：“（？（[0-9] +） - ？）+”。

我试着看看两个数字之间是否有任何减号。正则表达式应允许在数字之前但不在它们之间的最小值。

我使用以下命令行输入测试它：“4 6 8 2 5-3 4 3 9”，程序返回预期返回的内容（true为布尔值）。此外，当命令行输入为：“ - 4 6 8 2 5 -3 4 3 9”时，程序工作并返回false到布尔值（预期）。但是，每当我输入：“4 -6 8 2 5-3 4 3 9”时，程序会显示以下错误：

#include <type_traits>
#include <utility>

namespace detail {
   template <typename Pack>
   struct sequence_traits;

   template <typename T, template <T...> class Z, T... Is>
   struct sequence_traits<Z<Is...>>
    { using templ_empty = Z<>; };

   template <typename T, template <typename U, U...> class Z, T... Is>
   struct sequence_traits<Z<T, Is...>>
    { using templ_empty = Z<T>; };
 }

// accumulated
template <typename T, typename EmptyContainer, T...>
struct accumulated_h2;

template <typename T, template <typename U, U...> class Q, T ... Ts>
struct accumulated_h2<T, Q<T>, Ts...>
 { using type = Q<T, Ts...>; };

template <typename T, template <T...> class Q, T ... Ts>
struct accumulated_h2<T, Q<>, Ts...>
 { using type = Q<Ts...>; };

template <typename T, typename Sequence, typename, T...>
struct accumulated_h;

template <typename T, template <T...> class Z, typename EmptyContainer, T Sum, T... Is>
struct accumulated_h<T, Z<Sum, Is...>, EmptyContainer>
 { using type = typename accumulated_h2<T, EmptyContainer, Is..., Sum>::type; };

template <typename T, template <T...> class Z, T Sum, T... Is,
          typename EmptyContainer, T Next, T... Rest>
struct accumulated_h<T, Z<Sum, Is...>, EmptyContainer, Next, Rest...>
   : accumulated_h<T, Z<Sum + Next, Is..., Sum>, EmptyContainer, Rest...>
 { };

template <typename Sequence,
          typename = typename detail::sequence_traits<Sequence>::templ_empty>
struct accumulated;

template <typename T, template <T...> class Z, T First,
          T... Rest, typename EmptyContainer>
struct accumulated<Z<First, Rest...>, EmptyContainer>
   : accumulated_h<T, Z<First>, EmptyContainer, Rest...>
 { };

////// Added //////
template <typename T> struct squeeze {
    template <T... Is> struct Z;
    template <T... Is>
    using templ_type = Z<Is...>;
};

template <typename T, template <typename U, U...> class Z, T First,
          T... Rest, typename EmptyContainer>
struct accumulated<Z<T, First, Rest...>, EmptyContainer>
   : accumulated_h<T, typename squeeze<T>::template templ_type<First>, EmptyContainer, Rest...>
 { };
/////////

// Testing
template <int...>
struct Z;

template <int...>
struct Q;

template <std::size_t...>
struct I;

int main ()
 {
   static_assert(std::is_same<
      accumulated<Z<1,2,3,4,5>, Q<>>::type,
      Q<1,3,6,10,15>>::value);
   static_assert(std::is_same<
      accumulated<Z<1,2,3,4,5>>::type,
      Z<1,3,6,10,15>>::value);    
   static_assert(std::is_same<
      accumulated<Z<1,2,3,4,5>, std::integer_sequence<int>>::type,
      std::integer_sequence<int, 1,3,6,10,15>>::value);
   static_assert(std::is_same<
      accumulated<I<1,2,3,4,5>, std::integer_sequence<std::size_t>>::type,
      std::index_sequence<1,3,6,10,15>>::value);

    // Added
    static_assert(std::is_same<
      accumulated<std::index_sequence<1,2,3,4,5>>::type,
      std::index_sequence<1,3,6,10,15>>::value);    
 }

这意味着我的布尔值是假的，我不知道为什么，因为它应该返回true。

Answer 1

请查看您的( ?([0-9]+)-?)+ regex demo：只有4 6 8 2 5-3 4 3 9，4 -6 8 2 5-3 4 3 9和-4 6 8 2 5 -3 4 3 9部分匹配时，只有4 -6 8 2 5-3 4 3 9行符合整行。

如果您获得 false ，则表示您使用的是.matches()方法。你可以使用

(?: ?-?([0-9]+))+

请参阅此regex demo。

要获得您目前拥有的相同功能，并且如果将其与.matches()一起使用，您将匹配上面提供的所有四个字符串，而第1组将包含最后捕获的数字块（因为模式包含重复捕获组，只有最后一个数字将存储在.group(1)）。

<强>详情

^（隐含在.matches()） - 字符串的开头
(?: ?-?([0-9]+))+ - 出现1次或多次：
- ? - 可选空格
- -? - 可选的?
- ([0-9]+) - 第1组：一个或多个数字
$（隐含在.matches()） - 字符串结尾

Answer 2

您可以尝试 （（\ s）？\ d +（ - \ d）？）+ 它适用于所有情况。如果任何案件失败，请告诉我。对于Java代码，您可以使用 （（\ s）？\ d +（\ - \ d）？）+

我的正则表达式与某个输入不匹配 - java

2 个答案: