Great question. For a class method that it not const, I think we can consider the object to be an in-out parameter. And for const methods, an in-parameter. With this convention, the initial code, t.sort(“1stCol”), becomes the most explicit and simple.

Let’s say we create a table class with rows and columns populated with items.

Table t(100,100);
t.sort(“1stCol”);

What’s the sort method doing? is it modifying the object t inplace or is it returning a new sorted table?

If the intent is to create a new sorted table, isn’t more explicit to define a standalone function to sort and return a new Table?

Table sort( Table t, char* col) { …}

or perhaps a method that does both using an extra kewword?

Class Table() {

Table* sort (char* col, bool inplace) {

// Sort …

If (inplace) return this;
else return nestable;

}

};

Which solution better shows the intent? Which one is more explicit?

WINUSERAPI
int
WINAPI
wvsprintfW(
    _Out_ LPWSTR,
    _In_ _Printf_format_string_ LPCWSTR,
    _In_ va_list arglist);

Which is part of MS markers for documenting the semantics of API’s – The Microsoft Source Code Annotation Language (SAL). For more details see sal.h.

Yes you’re right, this is what I meant, this is now fixed. Thanks Miguel!

double getRatio(Item const& containingItem, Item const& item);

Second, this should be a member function of Item which eliminates the question about parameter ordering:

double getRatio(Item const& item) const { … }

Third, even if you want it as a standalone function it costs nothing to create specializations:

inline
double getRatio(const Bag& bag, const Book& book) {
return getRatio(bag, book);
}

The entire purpose of strong typing is to prevent these kind of problem.

You are right imo, was about to comment this as well.