Store csv data as rows or columns in view of the needed processing?

Is there another smart approach I didn't think about?

If your properties are of the same type and behave similar, why not address them by an index?

enum PropIndex{PropertyA=0, PropertyB=1, PropertyC=2};

struct Object {
    std::String name;
    std::vector<int> property(3); // use PropIndex to access the value you want

    // if that helps for convenience, you can also add getters and setters like this one 
    int getA(){ return property(PropertyA); }
    //  ... but then you should consider to make the public members 
    //  ... all private, and provide proper public getters/setter for all of them
};

Now you need to implement your maximum function only once (with an additional parameter which Property you want).

Approach 1 is unarguably the better design - it represents the "reality" of the data much better, which will make it much easier for future developers to understand.

So have both. There's no written rule that you must stick with the model you've chosen. You keep ObjectCollection class and have a method like getObject(int index) return a Object instance for all values of that row.

Your getObject method would simply have to lookup the values laterally across all vectors and put their references in Object class.

If you think you might need to call this method a lot, consider representing the data in both ways. Yes, that is to say, make ObjectCollection class hold vector column data as well as a single vector with Object instances. Obviously you'd be using up more memory, but this is the old memory-performance tradeoff. If you feel performance is more important here, don't hestitate to do it this way!

Domain goes first !

The design should aim at correctly representing the domain, before going into tactical considerations.

So approach 1 is the way to go. It perfectly reflects the real structure of your data, and it enforces separation of concerns between Collection and Object. For example, you could easily change the collection's container (e.g. replacing array with a map or a linked list) or the objects's properties (e.g. collection[i].average_abc()).

DRY using pointers to member

You can write a private helper function that would work with a pointer to member instead of a being bound to a specific member:

class ObjectCollection {
    size_t getMaxIndexOf(int Object::* o); // private helper function 
public:
    std::vector<Object> collection;
    size_t getMaxIndexOfA();
    size_t getMaxIndexOfB();
    size_t getMaxIndexOfC();
};

A pointer to member is a very special beast: it is relative to an object, so that you can use the same pointer and combine it with all items of your collection:

size_t ObjectCollection::getMaxIndexOf(int Object::* o) {
    size_t maxIndex = -1;
    int max = std::numeric_limits<int>::min();
    for (size_t i = 0; i < collection.size(); ++i) {
       if (collection[i].*o > max) {  // <---- use of the pointer to member
           maxIndex = i;
           max = collection[i].*o;  // <---- use of the pointer to member
       }
    }
    return maxIndex;
}

You can then reuse your helper function as follows:

size_t ObjectCollection::getMaxIndexOfA() {
    return getMaxIndexOf(&Object::a);
}
size_t ObjectCollection::getMaxIndexOfB() {
    return getMaxIndexOf(&Object::b);
}
size_t ObjectCollection::getMaxIndexOfC() {
    return getMaxIndexOf(&Object::c);
}

Here an online demo

DRY using standard algorithms

As suggested by Amon in the comments, you could just use std::max_element():

size_t ObjectCollection::getMaxIndexOfA() {
    auto it = std::max_element(collection.begin(), collection.end(), 
                            [](auto &o1, auto &o2){ return o1.a<o2.a; });
    return std::distance(collection.begin(), it);
}

This standard algorithm returns an iterator, but as shown, you can convert it back to an index.

Online demo