C ++ dois ou mais tipos de dados em declaração
Pergunta
Estou recebendo um erro estranho de g++
3,3 no código a seguir:
#include <bitset>
#include <string>
using namespace std;
template <int N, int M>
bitset<N> slice_bitset(const bitset<M> &original, size_t start) {
string str = original.to_string<char, char_traits<char>, allocator<char> >();
string newstr = str.substr(start, N);
return bitset<N>(newstr);
}
int main() {
bitset<128> test;
bitset<12> result = slice_bitset<12, 128>(test, 0);
return 0;
}
O erro é o seguinte:
In function `std::bitset slice_bitset(const std::bitset&, unsigned int)': syntax error before `,' token `char_traits' specified as declarator-id two or more data types in declaration of `char_traits' `allocator' specified as declarator-id two or more data types in declaration of `allocator' syntax error before `>' token
Tem que ser algo realmente bobo, mas eu já disse isso ao meu pato de borracha e um amigo sem sucesso.
Obrigado, lazyweb.
Solução
A resposta seleccionada a partir CAdaker acima resolve o problema, mas não explica por ele resolve o problema.
Quando um modelo de função está sendo analisado, a pesquisa não ocorre em tipos dependentes. Como resultado, constrói como a seguinte pode ser analisado:
template <typename T>
class B;
template <typename T>
void foo (B<T> & b) {
// Use 'b' here, even though 'B' not defined
}
template <typename T>
class B
{
// Define 'B' here.
};
No entanto, este "recurso" tem um custo, e neste caso é que a definição de 'foo' requer sugestões sobre o conteúdo do template 'B'. Se 'foo' usa um tipo aninhado de 'B', em seguida, a palavra-chave typename
é necessário para dizer ao compilador que o nome é um tipo:
template <typename T>
void foo (B<T> & b)
{
typename B<T>::X t1; // 'X' is a type - this declares t1
B<T>::Y * t1; // 'Y' is an object - this is multiplication
}
Sem 'typename' no exemplo acima o compilador irá assumir que X
é um objeto (ou função).
Se uma função membro é chamado e a chamada tem argumentos de modelo explícitas, em seguida, as necessidades do compilador saber para tratar a <
como o início de uma lista de argumentos modelo e não a menos de operador:
template <typename T>
void foo (B<T> & b)
{
b.template bar<int> (0); // 'bar' is a template, '<' is start of arg list
b.Y < 10; // 'Y' is an object, '<' is less than operator
}
Sem template
, o compilador assume que <
é a menos de operador, e assim gera o erro de sintaxe quando vê int>
desde que isso não é uma expressão.
Essas dicas são obrigados até quando a definição do modelo é visível. A razão é que uma especialização explícita pode alterar posteriormente a definição que é realmente escolhido:
template <typename T>
class B
{
template <typename S>
void a();
};
template <typename T>
void foo (B<T> & b)
{
b.a < 10; // 'B<int>::a' is a member object
}
template <>
class B<int>
{
int a;
};
Outras dicas
Use ou apenas
original.to_string();
ou, se você realmente precisa os especificadores de tipo,
original.template to_string<char, char_traits<char>, allocator<char> >();
A seguir, compilado por mim (usando gcc 3.4.4):
#include <bitset>
#include <string>
using namespace std;
template <int N, int M>
bitset<N> slice_bitset(const bitset<M> &original, size_t start)
{
string str = original.to_string();
string newstr = str.substr(start, N);
return bitset<N>(newstr);
}
int main()
{
return 0;
}