Optimising single-delimiter string tokenisation

You will be able to avoid one call to strtok by returning from the function or breaking from the while loop when col == 9. Of course, you don't need to check whether ++col < 10 in that case.

int col = 0;
char *row = &line[0];
char *token = strtok(row, "\t");
while (token)
{
    ++col;
    switch(col):
    {
        case 2 : input_struct.a = token; break;
        case 4 : input_struct.b = token; break;
        case 9 : input_struct.f = atoi(token); return;
    }
    token = strtok(NULL, "\t");
}

or

int col = 0;
char *row = &line[0];
char *token = strtok(row, "\t");
while (token)
{
    ++col;
    switch(col):
    {
        case 2 : input_struct.a = token; break;
        case 4 : input_struct.b = token; break;
        case 9 : input_struct.f = atoi(token);
    }
    if ( col == 9 )
    {
       break;
    }
    token = strtok(NULL, "\t");
}

Untested suggestion: get rid of a switch. Making a decision for each token surely eats up time.

char * tokens[10];
while (token && col < 10) {
    tokens[col++] = token;
    token = strtok(NULL, "\t");
}
input_struct.a = tokens[2];
input_struct.b = tokens[4];
input_struct.f = atoi(tokens[9]);

You may use some non intrusive splitting into desired tokens which is not altering the input string (strtok does). An (ugly) one might be:

#include <cstring>
#include <iostream>

inline const char* skip_token(std::size_t skip, char token, const char* line) {
    const char* result = line;
    while(skip && result) {
        result = std::strchr(result, token);
        if(result) {
            ++result;
            --skip;
        }
    }
    return result;
}

int main() {
    const char* line = "1-2-3-4-5-6-7-8-9-10-11-12   ";
    const char* first = nullptr;
    const char* last = nullptr;

    first = skip_token(1, '-', line);
    if(first) {
        last = skip_token(1, '-', first);
        if(last) {
            std::cout << std::string(first, last - 1) << '\n';
            first = skip_token(1, '-', last + 1);
            if(first) {
                last = skip_token(1, '-', first);
                if(last) {
                    std::cout << std::string(first, last - 1) << '\n';
                    first = skip_token(4, '-', last + 1);
                    if(first) {
                        last = skip_token(1, '-', first);
                        if(last) {
                            std::cout << std::string(first, last - 1) << '\n';
                        }
                    }
                }
            }
        }
    }
}

(In this sample '-' is the separator)

A couple of notes -- you say you have tab separated columns, but then you use strtok which won't actually work correctly for that if you have empty columns. strtok will treat two or more consecutive delimiters as a single separator. This may be what you want, or your code may be accidentally working because you never have empty columns. If you want to allow for empty columns (and want them to be counted as columns), you should use strsep instead of strtok

If you should be using strsep, or if you never have double tabs (so it doesn't matter), you might be able to make the code slightly faster by using strchr instead of strsep and unrolling your loop:

char *token = strchr(line, '\t');  /* skip column 1 */
if (token) {  /* column 2 */
    input_struct.a = ++token;
    token = strchr(token, '\t'); }
if (token) {
    *token++ = '\0';
    token = strchr(token, '\t'); }
if (token) {  /* column 4 */
    input_struct.b = ++token;
    token = strchr(token, '\t'); }
if (token) {
    *token++ = '\0';
    token = strchr(token, '\t'); }
if (token) token = strchr(token+1, '\t'); /* skip col 6 */
if (token) token = strchr(token+1, '\t');
if (token) token = strchr(token+1, '\t'); /* skip col 8 */
if (token) input_struct.f = atoi(++token);

This has the advantage of not inserting NULs where they aren't needed, and not having hard-to-predict branches.