Вложенная шаблонная специализация
s = r'abc123d, hello 3.1415926, this is my book'
print re.findall(r'-?[0-9]+(?:\.[0-9]*)?|-?\.[0-9]+',s)
Вам не нужно escape дважды, когда вы используете raw mode.
Выход: ['123', '3.1415926']
Также тип возврата будет списком strings .Если вы хотите, чтобы возвращаемый тип, как integers и floats, использовал map
import re,ast
s = r'abc123d, hello 3.1415926, this is my book'
print map(ast.literal_eval,re.findall(r'-?[0-9]+(?:\.[0-9]*)?|-?\.[0-9]+',s))
Выход: [123, 3.1415926]
6 ответов
Да, вы можете. Но вам нужно изменить структуру вызовов, но чуть-чуть.
В частности, используйте шаблон стратегии для реструктуризации реализации функции-члена как класса (который разрешен быть специализированным).
Это разрешено, если класс стратегии не является вложенным (и, следовательно, не зависит от неспециализированного типа шаблона).
например. (это, вероятно, не является синтаксически правильным, но идея должна быть ясной)
template <class T>
class OuterThingThatIsNotSpecialized
{
template <class U>
void memberWeWantToSpecialize(const U& someObj_)
{
SpecializedStrategy<U>::doStuff(someObj_);
}
};
template <class U>
struct SpecializedStrategy;
template <>
SpecializedStrategy<int>
{
void doStuff(const int&)
{
// int impl
}
};
template <>
SpecializedStrategy<SomeOtherType>
{
void doStuff(const SomeOtherType&)
{
// SOT impl
}
};
Это невероятно полезно, потому что вызовы OuterThingThatIsNotSpecialized для типов, где не существует реализации, просто не смогут скомпилироваться.
PS. Вы даже можете использовать эту стратегию для частичной специализации шаблонных функций, что в противном случае невозможно в C ++.
Согласно этим сообщениям:
http://www.cpptalk.net/template-member-function-specialization-vt11666.html
вы не можете специализироваться члены шаблона класса шаблона без специализации внешнего класса. Они не цитируют стихи и главы. Моя копия "языка программирования C ++" не раскрывает ничего сразу, и моя копия стандарта находится дома (моей резервной копии, более известной здесь как "Крис", тоже нет рядом: -)
Вот то, что я делал, и я думаю, что это проще / больше соответствует тому, что вы пытаетесь сделать:
С Помощником
template<int a> struct Foo
{
template<int, int> struct Bar__;
template<int b> using Bar = Bar__<b, b>;
};
template<int a> template<int b, int c> struct Foo<a>::Bar__
{
// general case
const static int x = 0;
};
template<int a> template<int b> struct Foo<a>::Bar__<b, 1>
{
const static int x = 1;
};
int main(int argc, const char * argv[])
{
std::cout << Foo<1>::Bar<0>::x << "\r\n"; // general case - output 0
std::cout << Foo<1>::Bar<1>::x << "\r\n"; // specialized case - output 1
return 0;
}
ИЛИ - Помощник может быть удален, если вы не против удвоить специализацию каждый раз:
Без помощника
template<int a> struct Foo
{
template<int b, int c> struct Bar;
};
template<int a> template<int b, int c> struct Foo<a>::Bar
{
// general case
const static int x = 0;
};
template<int a> template<int b> struct Foo<a>::Bar<b, 1>
{
const static int x = 1;
};
int main(int argc, const char * argv[])
{
std::cout << Foo<1>::Bar<0, 0>::x << "\r\n"; // general case - output 0
std::cout << Foo<1>::Bar<1, 1>::x << "\r\n"; // specialized case - output 1
return 0;
}
Вы не можете этого сделать. Я перепробовал много вариантов. Это , однако, компилируется в GCC 4.1:
template<int a> struct Foo
{
template<int b> struct Bar;
template<1> struct Bar;
};
Редактировать (после рассмотрения стандарта): Однако, если дано a, вы можете сделать это:
template <> template <> Foo<1> Bar<1>;
Но не тогда, когда Фу не специализируется в первую очередь.
Как объяснили предыдущие постеры, это невозможно. Однако вы можете переместить вложенный шаблон в базовый класс без шаблона:
struct FooBase
{
template<int b> struct Bar;
}
template<int a> struct Foo : public FooBase
{
};
struct FooBase::Bar<1> // specializing Bar
{
};
В пункте 18 раздела 14.7.3 стандарта 1998 г. (ISO14882: 1998) говорится, что явная специализация (внутренних) классов-членов шаблона недопустима, если (внешний) класс-шаблон не указан явно специализированный.