Por que string :: compare retorna um int?

Por que string::compareretorna um em intvez de um tipo menor como shortou char? Meu entendimento é que esse método retorna apenas -1, 0 ou 1.

Segunda parte, se eu fosse projetar um método de comparação que compare dois objetos do tipo Fooe quisesse apenas retornar -1, 0 ou 1, usar shortou chargeralmente seria uma boa ideia?

EDIT: Fui corrigido, string::comparenão retorna -1, 0 ou 1, na verdade retorna um valor> 0, <0 ou 0. Obrigado por me manter na linha, pessoal.

Parece que a resposta é aproximadamente, não há razão para retornar um tipo menor do que intporque os valores de retorno são "rvalues" e esses "rvalues" não se beneficiam de serem menores do que o tipo int (4 bytes). Além disso, muitas pessoas apontaram que os registros da maioria dos sistemas provavelmente serão de tamanho de intqualquer maneira, uma vez que esses registros serão preenchidos independentemente de você dar a eles um valor de 1, 2 ou 4 bytes, não há nenhuma vantagem real em retornar um valor menor.

EDIT 2: Na verdade, parece que pode haver sobrecarga de processamento extra ao usar tipos de dados menores, como alinhamento, mascaramento, etc. O consenso geral é que os tipos de dados menores existem para economizar memória ao trabalhar com muitos dados, como no caso de uma matriz.

Aprendi algo hoje, obrigado novamente pessoal!

Em primeiro lugar, a especificação é que ele retornará um valor menor, igual ou maior que 0, não necessariamente -1ou 1. Em segundo lugar, os valores de retorno são rvalues, sujeitos à promoção integral, portanto, não faz sentido retornar nada menor.

Em C ++ (como em C), cada expressão é um rvalue ou um lvalue. Historicamente, os termos referem-se ao fato de que lvalues ​​aparecem à esquerda de uma atribuição, enquanto rvalues ​​só podem aparecer à direita. Hoje, uma aproximação simples para tipos de não classe é que um lvalue tem um endereço na memória, um rvalue não. Portanto, você não pode obter o endereço de um rvalue, e os qualificadores cv (cuja condição "acesso") não se aplicam. Em termos de C ++, um rvalue que não tem tipo de classe é um valor puro, não um objeto. O valor de retorno de uma função é um rvalue, a menos que tenha um tipo de referência. (Tipos de não classe que cabem em um registro quase sempre serão retornados em um registro, por exemplo, ao invés de na memória.)

Para tipos de classe, os problemas são um pouco mais complexos, devido ao fato de que você pode chamar funções de membro em um rvalue. Isso significa que rvalues ​​devem de fato ter endereços, para o this ponteiro, e podem ser cv-qualificados, visto que a cv-qualification desempenha um papel na resolução da sobrecarga. Finalmente, C ++ 11 introduz várias novas distinções, a fim de oferecer suporte a referências rvalue; estes também são principalmente aplicáveis ​​aos tipos de classe.

A promoção integral refere-se ao fato de que, quando tipos integrais menores do que um intsão usados ​​como rvalues ​​em uma expressão, na maioria dos contextos, eles serão promovidos para int. Portanto, mesmo que eu tenha uma variável declarada short a, b;, na expressão a + b, ambos ae bsão promovidos a intantes de ocorrer a adição. Da mesma forma, se eu escrever a < 0, a comparação é feita no valor de a, convertido em um int. Na prática, existem poucos casos em que isso faz diferença, pelo menos nas máquinas de complementos de 2 onde a aritmética de inteiros envolve (ou seja, todos, exceto alguns exóticos, hoje - acho que os mainframes da Unisys são as únicas exceções restantes). Ainda assim, mesmo nas máquinas mais comuns:

short a = 1;
std::cout << sizeof( a ) << std::endl;
std::cout << sizeof( a + 0 ) << std::endl;

deve dar resultados diferentes: o primeiro é equivalente a sizeof( short ), o segundo sizeof( int )(por causa da promoção integral).

Essas duas questões são formalmente ortogonais; rvalues ​​e lvalues ​​não têm nada a ver com promoção integral. Exceto ... a promoção integral só se aplica a rvalues, e a maioria (mas não todos) dos casos em que você usaria um rvalue resultará em promoção integral. Por esse motivo, não há realmente nenhuma razão para retornar um valor numérico em algo menor que int. Há até uma razão muito boa para não devolvê-lo como um tipo de personagem. Operadores sobrecarregados, como <<, geralmente se comportam de maneira diferente para os tipos de caracteres, então você só deseja retornar os caracteres como tipos de caracteres. (Você pode comparar a diferença:

char f() { return 'a'; }
std::cout << f() << std::endl;      //  displays "a"
std::cout << f() + 0 << std::endl;  //  displays "97" on my machine

A diferença é que, no segundo caso, a adição fez com que ocorresse a promoção integral, o que resulta em uma sobrecarga diferente de <<ser escolhido.

É intencional que não retorne -1, 0 ou 1.

Ele permite (observe que não é para strings, mas se aplica igualmente a strings)

int compare(int *a, int *b)
{
   return *a - *b;
}

o que é muito menos complicado do que:

int compare(int *a, int *b)
{
   if (*a == *b) return 0;
   if (*a > *b) return 1;
   return -1;
}

que é o que você teria que fazer [ou algo nesse sentido] se você tivesse que retornar -1, 0 ou 1.

E também funciona para tipos mais complexos:

class Date
{
    int year;
    int month;
    int day;
}

int compare(const Date &a, const Date &b)
{
   if (a.year != b.year) return a.year - b.year;
   if (a.month != b.month) return a.month - b.month;
   return a.day - b.day;
}

No caso da string, podemos fazer isso:

int compare(const std::string& a, const std::string& b)
{
   int len = min(a.length(), b.length());

   for(int i = 0; i < len; i++)
   {
      if (a[i] != b[i]) return a[i] - b[i];
   }
   // We only get here if the string is equal all the way to one of them
   // ends. If the length isn't equal, "longest" wins. 
   return a.length() - b.length();
}

int é geralmente (ou seja, na maioria dos hardwares modernos) um inteiro do mesmo tamanho que o barramento do sistema e / ou os registradores da CPU, o que é chamado de palavra de máquina. Portanto, o int é normalmente transmitido mais rápido do que os tipos menores, porque não requer alinhamento, mascaramento e outras operações.

Os tipos menores existem principalmente para permitir a otimização do uso de RAM para arrays e estruturas. Na maioria dos casos, eles trocam alguns ciclos de CPU (na forma de operações de alinhamento) por um melhor uso de RAM.

A menos que você precise fazer com que seu valor de retorno seja um número com ou sem sinal de um tamanho centain (char, short ...), é melhor usar int, e é por isso que a biblioteca padrão faz isso.

É um C-ismo.

Quando C requer comparefunções -type, elas sempre retornam um int. C ++ apenas levou isso adiante (infelizmente).

No entanto, retornar um inté realisticamente provavelmente a maneira mais rápida, pois geralmente é o tamanho dos registros do sistema em uso. (Deliberadamente vago.)

O método não retorna realmente um inteiro no conjunto { -1, 0, 1 }; na verdade, pode ser qualquer valor integral.

Por quê? A principal razão que consigo pensar é que esse inté o valor de "tamanho natural" da arquitetura; operações em valores desse tamanho são normalmente pelo menos tão rápidas (e em muitos casos mais rápidas) do que operações em valores menores ou maiores. Portanto, este é um caso de permitir a implementação folga suficiente para usar o que for mais rápido.

se eu fosse projetar um método de comparação que compare dois objetos do tipo Foo e só quisesse retornar -1, 0 ou 1, usar short ou char geralmente seria uma boa ideia?

Seria uma boa ideia. A melhor maneira seria retornar um bool (se quiser apenas comparar se for igual) ou enum (para obter mais informações):

enum class MyResult
{
  EQUAL,
  LESS,
  GREATER
};

MyResult AreEqual( const Foo &foo1, const Foo & foo2 )
{
  // calculate and return result
}

Suponha que algumas pessoas estejam mudando um código de C para C ++. Eles decidiram substituir strcmppor string::compare.

Desde que strcmpretorna int, é mais fácil string::comparedevolver int, como um presente.

Provavelmente para fazer funcionar mais como strcmpaquele que também tem esse conjunto de valores de retorno . Se você quisesse portar código, provavelmente seria mais intuitivo ter substitutos que se separassem o mais próximo possível.

Além disso, o valor de retorno não é apenas -1, 0ou , 1mas <0, 0ou >0.

Além disso, conforme mencionado, uma vez que o retorno está sujeito a promoção integral , não faz sentido diminuí-lo.

porque um valor de retorno booleano só pode ter dois valores possíveis (verdadeiro, falso) e uma função de comparação pode retornar três valores possíveis (menor que, igual, maior que).

Atualizar

Embora seja certamente possível retornar um short assinado, se você realmente quiser implementar sua própria função de comparação, poderá retornar um valor nibble ou struct com dois booleanos.