Literal de seqüência de caracteres
A manipulação de seqüências literais mudou de gerenciado Extensions para C++ para Visual C++ 2008.
Na extensões gerenciadas para design de linguagem C++, um literal de string gerenciada foi indicada pelo antecedendo a seqüência literal com um S. Por exemplo:
String *ps1 = "hello";
String *ps2 = S"goodbye";
O desempenho sobrecarga entre sistema autônomo duas inicializações é não-comum, sistema autônomo a representação CIL seguinte demonstra sistema autônomo visto por meio de ildasm:
// String *ps1 = "hello";
ldsflda valuetype $ArrayType$0xd61117dd
modopt([Microsoft.VisualC]Microsoft.VisualC.IsConstModifier)
'?A0xbdde7aca.unnamed-global-0'
newobj instance void [mscorlib]System.String::.ctor(int8*)
stloc.0
// String *ps2 = S"goodbye";
ldstr "goodbye"
stloc.0
Que é uma excelente economia para apenas lembrar (ou aprendizagem) prefixar uma seqüência de caracteres literal com um S. Na sintaxe de novo, a manipulação de seqüências literais é feita transparente, determinado pelo contexto de uso.The S não deve ser especificado.
Que tal casos em que precisamos explicitamente direcionam o compilador a interpretação de um ou outro?Nesses casos, aplicamos uma conversão explícita.Por exemplo:
f( safe_cast<String^>("ABC") );
Além disso, a seqüência literal agora coincide com um String com uma conversão simples em vez de uma conversão padrão. Enquanto isso pode não parecer muito alterações a resolução da função sobrecarregada define que incluem um String e um const char* sistema autônomo parâmetros formais de concorrentes. A resolução de uma vez resolvido para um const char* instância é agora sinalizado sistema autônomo ambíguo. Por exemplo:
ref struct R {
void f(const char*);
void f(String^);
};
int main () {
R r;
// old syntax: f( const char* );
// new syntax: error: ambiguous
r.f("ABC");
}
Por que há uma diferença?Desde a mais de uma instância nomeada f existe dentro do programa, isso requer que o algoritmo de resolução de sobrecarga de função a ser aplicado a telefonar. A resolução formal de uma função de sobrecarga envolve três etapas.
A coleção das funções do candidato.As funções de candidatos são esses métodos dentro do escopo léxico corresponder ao nome da função que está sendo chamado.Por exemplo, desde f() é invocado por meio de uma ocorrência da R, todos denominado funções f que não são um membro de R (ou de sua hierarquia de classe base) não são funções de candidato. Em nosso exemplo, há duas funções do candidato.Estas são as funções de dois membros de R chamada f. Uma telefonar de falha durante essa fase se o conjunto de função Candidato está vazio.
O conjunto de funções viáveis entre as funções do candidato.Uma função viável é aquele que pode ser chamado com os argumentos especificados na telefonar, dado o número de argumentos e seus tipos.Em nosso exemplo, ambas as funções de candidato também são funções viáveis.Uma telefonar de falha durante essa fase se o conjunto de funções viável estiver vazio.
selecionar a função que representa a melhor correspondência da telefonar.Para fazer isso, as conversões aplicadas a transformar os argumentos para o tipo dos parâmetros da função viável de classificação.Isso é relativamente straight-encaminhar com uma único parâmetro de função; torna um pouco mais complexa quando há vários parâmetros.Uma telefonar de falha durante essa fase se não houver nenhuma correspondência melhor.Ou seja, se as conversões necessárias para transformar o tipo do argumento real do tipo de parâmetro formal forem igualmente mercadoria.A telefonar é sinalizado sistema autônomo ambíguo.
Em extensões gerenciadas, a resolução desta telefonar telefonar a const char* instância sistema autônomo a melhor correspondência. Na sintaxe de novo, a conversão necessária para corresponder à "abc" para const char* e String^ agora são equivalentes – ou seja, igualmente mercadoria – e, portanto, a telefonar é sinalizada sistema autônomo incorreta – ou seja, sistema autônomo ambíguo.
Isso nos leva a duas perguntas:
Qual é o tipo do argumento real, "abc"?
O que é o algoritmo para determinar quando uma conversão de tipo é melhor que outro?
O tipo da seqüência de caracteres literal "abc" é const char[4] – Lembre-se de que um caractere de terminação nulo implícito no participante de cada seqüência de caracteres é literal.
O algoritmo para determinar quando uma conversão de tipo é melhor que outro envolve colocar as conversões de tipo possíveis em uma hierarquia.Aqui está minha compreensão dessa hierarquia – essas conversões, obviamente, são implícitos.Usando a notação de uma conversão explícita substitui a hierarquia semelhante à forma como parênteses substitui a precedência de operador usual de uma expressão.
Recomenda-se uma correspondência exata.Surpreendentemente, um argumento ser uma correspondência exata, ele não precisa correspondam exatamente o tipo de parâmetro; ele só precisa ser próxima o suficiente.Esta é a chave para compreender o que está acontecendo neste exemplo e como o linguagem foi alterada.
Uma promoção é melhor do que uma conversão padrão.Por exemplo, promovendo um short int para um int é melhor do que a conversão de um int em um double.
Uma conversão padrão é melhor do que uma conversão boxing.Por exemplo, convertendo um int em um double é melhor que conversão boxing um int em um Object.
Uma conversão boxing é melhor do que uma conversão implícita definida pelo usuário.Por exemplo, conversão boxing um int em um Object é melhor do que a aplicação de um operador de conversão de um SmallInt classe de valor.
Uma conversão implícita definida pelo usuário é melhor que nenhuma conversão.Uma conversão implícita definida pelo usuário é a última instrução de sair antes de erro (com a advertência que assinatura formal pode conter uma matriz de parâmetro ou reticências nessa posição).
Portanto, o que significa dizer que uma correspondência exata não é necessariamente exatamente uma correspondência?Por exemplo, const char[4] corresponder exatamente a um const char* ou String^, e ainda a ambigüidade do nosso exemplo é entre duas correspondências exatas conflitantes!
Uma correspondência exata, quando isso acontece, inclui um número de conversões simples.Há quatro conversões triviais em ISO-C++ que podem ser aplicadas e ainda se qualificam sistema autônomo uma correspondência exata.Três são chamados sistema autônomo lvalue transformações.O tipo de quarto é chamado de uma conversão de qualificação.Três transformações lvalue são tratadas sistema autônomo uma melhor correspondência exata de um que requer uma conversão de qualificação.
Um formulário da transformação lvalue é a conversão de array nativo de ponteiro.Este é o que está envolvido na correspondência de um const char[4] para const char*. Portanto, a correspondência de f("abc") para f(const char*) é uma correspondência exata. Em manifestações anteriores do nosso linguagem, isso era na verdade a melhor correspondência.
Para o compilador sinalizar a telefonar sistema autônomo ambíguo, portanto, requer que a conversão de um const char[4] para um String^ também é uma correspondência exata por meio de uma conversão simples. Esta é a alterar foi introduzida na nova versão de linguagem.E isso é por que a telefonar agora está sinalizada sistema autônomo ambíguo.