Modulo operation vs. Ternary operation - c++

Question

I need to iterate over n pairs of integers: (0, 1), (1, 2), (2, 3) ... (n-2, n-1), (n-1, 0)
What's the best way to do it?
Using modulo operation:
for (int i = 0; i < n; i++){
int a = i;
int b = (i + 1)%n
//MaaaanyLinesOfDoSomethingWithAAndB
}
Using ternary operation:
for (int i = 0; i < n; i++){
int a = i;
int b = (i + 1 == n ? 0 : i + 1)
//MaaaanyLinesOfDoSomethingWithAAndB
}
Or:
for (int i = 0; i < n; i++){
int a = i;
int b = (i + 1 >= n ? 0 : i + 1)
//MaaaanyLinesOfDoSomethingWithAAndB
}
Another idea? Let's assume that there are maaaany lines of do something and it'd look ugly if we do (0, 1), (1, 2), (2, 3) ... (n-2, n-1) part and (n-1, 0) part separately.
Which operation is the most efficient one?
EDIT #1
I'm sorry, I think I haven't asked my question properly. I wanted to know which operator acts faster (in, e.g. seconds or clock ticks). I also decided to make little experiment and just measure it by clock() function. Here's my code:
#include <time.h>
#include <limits.h>
#include <string>
#include <iostream>
using namespace std;
typedef void (*fun) (int a);
void DoSomething(int i){
int a = i;
}
void ModuloOperation (int n){
for (int i = 0; i < n; i++)
DoSomething((i + 1) % n);
}
void TernaryEqual (int n){
for (int i = 0; i < n; i++)
DoSomething(i + 1 == n ? 0 : i + 1);
}
void TernaryBiggerEqual (int n){
for (int i = 0; i < n; i++)
DoSomething(i + 1 >= n ? 0 : i + 1);
}
void SplitIntoTwoParts (int n){
for (int i = 0; i < n - 1; i++)
DoSomething(i + 1);
DoSomething(n - 1);
}
int main(){
const int n = INT_MAX;
string testNames[] = {
"Modulo",
"Trenary equal",
"Trenary bigger equal",
"Split into two parts"
};
fun tests[] = {
ModuloOperation,
TernaryEqual,
TernaryBiggerEqual,
SplitIntoTwoParts
};
clock_t t;
for (int i = 0; i < sizeof(testNames)/sizeof(testNames[0]); i++){
t = clock();
tests[i](n);
t = clock() - t;
cout<<testNames[i]<<": "<<((float)t)/CLOCKS_PER_SEC<<" seconds\n\n";
}
return 0;
}
And here's an output
Modulo: 53.867 seconds
Trenary equal: 36.684 seconds
Trenary bigger equal: 37.299 seconds
Split into two parts: 31.37 seconds
So it seems that p.s.w.g's idea is not only the cleanest one but also the best one.
And once again, sorry for my mistake, I'm not native speaker, I'm still learning.

Answer 1

You mentioned that it would look ugly if you do the 'maaaany' lines separately. None of the above options are particularly pretty either. So perhaps it's better to encapsulate this ugly logic in a method and use some more elegant code in your loop.
For readability, I'd probably go with this:
for (int i = 0; i < n - 1; i++){
DoStuff(i, i + 1);
}
DoStuff(n - 1, 0);
// elsewhere
void DoStuff(int a, int b)
{
//MaaaanyLinesOfDoSomethingWithAAndB
}
If the 'maaaany' lines require the use of a number local variables and you don't want to pass them all in to the DoStuff method, you might want to consider using a closure, although it wouldn't help the readability of your code nearly as much as proper functional decomposition. Something like this:
Action<int, int> doStuff = (a, b) =>
{
//MaaaanyLinesOfDoSomethingWithAAndB
};
for (int i = 0; i < n - 1; i++){
doStuff(i, i + 1);
}
doStuff(n - 1, 0);
Or perhaps you need to refactor the 'maaaany' lines into a separate worker class, but without knowing more about what's in those lines, it's hard to say.