Puis-je augmenter le nombre d'int i de plus d'une unité en utilisant la syntaxe i++ ?

Question

Int fkt(int &i) { retour i++ ; }

int main()
{
  int i = 5;
  printf("%d ", fkt(i));
  printf("%d ", fkt(i));
  printf("%d ", fkt(i));
}

imprime '5 6 7 '. Si je veux imprimer '5 7 9 ' comme ceci, est-il possible de le faire de manière similaire sans variable temporaire dans fkt() ? (Une variable temporaire diminuerait marginalement l'efficacité, n'est-ce pas ?) C'est-à-dire quelque chose comme

return i+=2 

o

return i, i+=2; 

qui à la fois augmentent d'abord i et le renvoient ensuite, ce qui n'est pas ce dont j'ai besoin.

Merci

EDIT : La raison principale pour laquelle je le fais dans une fonction et non en dehors est que fkt sera un pointeur de fonction. La fonction originale fera quelque chose d'autre avec i. J'ai juste l'impression qu'utiliser {int temp = i ; i+=2 ; return temp;} n'est pas aussi agréable que {return i++;}.

Je ne me soucie pas de printf, c'est juste pour illustrer l'utilisation du résultat.

EDIT2 : Wow, cela semble être plus un chat ici qu'un forum traditionnel :) Merci pour toutes les réponses. Mon fkt est en fait le suivant. En fonction de certaines conditions, je définirai get_it comme étant soit get_it_1, soit get_it_2, soit get_it_4 :

unsigned int (*get_it)(char*&);

unsigned int get_it_1(char* &s)
  {return *((unsigned char*) s++);}
unsigned int get_it_2(char* &s)
  {unsigned int tmp = *((unsigned short int*) s); s += 2; return tmp;}
unsigned int get_it_4(char* &s)
  {unsigned int tmp = *((unsigned int*) s); s += 4; return tmp;}

Pour get_it_1, c'est très simple... J'essaierai de donner plus de détails à l'avenir...

Answer 1

Eh bien, vous pourriez faire

return i+=2, i-2;

Cela dit, suivez cette simple maxime :

Écrivez un code facile à comprendre.

Un code facile à comprendre pour un humain est généralement facile à comprendre pour le compilateur, qui peut donc l'optimiser.

Écrire des choses folles dans le but d'optimiser votre code ne fait souvent qu'embrouiller le compilateur et lui rendre plus difficile l'optimisation de votre code.

Je recommande

int fkt(int &i)
{
    int orig = i;
    i += 2;
    return orig;
}

Answer 2

Une "variable temporaire" ne diminuera très probablement pas les performances, car i++ doit conserver l'ancien état en interne (c'est-à-dire qu'il utilise implicitement ce que vous appelez une variable temporaire). Cependant, l'instruction nécessaire pour augmenter par deux peut être plus lente que celle utilisée pour ++.

Vous pouvez essayer :

int fkt(int &i)
{
  ++ii;
  return i++;
}

Vous pouvez le comparer à :

int fkt(int &i)
{
  int t = i;
  i += 2;
  return t;
}

Cela dit, je ne pense pas que vous devriez faire de telles considérations de performance prématurément.

Answer 3

Je pense que ce que vous voulez vraiment est un foncteur :

class Fkt
{
   int num;
public:
   Fkt(int i) :num(i-2) {}
   operator()() { num+=2; return num; }
}

int main() 
{ 
  Fkt fkt(5); 
  printf("%d ", fkt()); 
  printf("%d ", fkt()); 
  printf("%d ", fkt()); 
}

Answer 4

Qu'en est-il

int a = 0;
++++a;

Incrémente +2 sans variables temporaires.

EDIT : Oups, désolé : je n'avais pas remarqué que vous vouliez réaliser 5,7,9. Cela nécessite des variables temporaires, donc la notation par préfixe ne peut pas être utilisée.