Una statement de devolución más concisa

Recientemente comencé a progtwigr en C y me preguntaba sobre una forma más concisa de escribir una función simple que devuelva 1 o -1 según la igualdad de dos valores int. Lo que escribí:

int valueCompare(int i, int j) { if (i != j) { return -1; } else { return 1; } } 

Es legible pero parece ineficiente. He visto declaraciones de devolución que utilizan dos puntos y un signo de interrogación, sin embargo no estoy familiarizado con ese estilo. ¿Alguien tiene alguna recomendación sobre cómo escribir una función más eficiente para esto sin una pérdida de legibilidad?

Puede utilizar el operador ternario:

 int valueCompare(int i, int j) { return (i == j) ? 1 : -1; } 

Para facilitar la lectura, considere reescribir la función para usar la lógica booleana en su lugar:

 #include  bool isEqual (int i, int j) { return i == j; } 

Esta es, en mi opinión, la forma más legible posible.


O, alternativamente, para propósitos de progtwigción / portabilidad / utilidad generics, debe hacer un “functor” estándar de facto de progtwigción en C para la comparación de valores:

 int compare_int (const void* i1, const void* i2) { const int* ip1 = i1; const int* ip2 = i2; return *ip1 - *ip2; } 

Esto tiene muchas ventajas:

  • Formato genérico de la función.
  • Estándar. Se puede pasar a funciones como bsearch, qsort etc.
  • Mezcla de igualdad, menor que y mayor que cheques en una sola función.
  • Compatible con comstackdores de dinosaurios.

Es legible y es responsabilidad del comstackdor hacerlo eficiente. Cualquier forma “inteligente” de escribirlo será menos legible y no será más eficiente.

Básicamente, lo dejaría en omitir las llaves cuando hay una sola statement e incluso eso es una cuestión de gusto:

 if(i != j) return -1; else return 1; 

contra

 if(i != j) { return -1; } else { return 1; } 

contra

 if(i != j) { return -1; } else { return 1; } 

Por supuesto que puedo pensar en muchas maneras “inteligentes” de escribirlo desde

 return (i != j) ? -1 : 1; 

eso solo es apropiado para expresiones simples (es decir, está bien, pero agregue un par de llamadas a funciones y será totalmente ilegible) para

 return 2 * (i == j) - 1; 

pero esto es apenas legible . Sin embargo, deberías poder entenderlo, porque podrías ver este tipo de cosas en la naturaleza.

Y no hay absolutamente nada en ninguno de los dos para hacerlos más eficientes.

Qué tal si

 #define SAME_VALUE 1 #define DIFFERENT_VALUE -1 

O similar ? y ¿qué tal

  int valueCompare (int i, int j){ return i == j; }