CODEWITHSUNDEEP
c++
mireazma
mireazma

Reputation: 556

Is there a way to use only the object name of a class as a "default" member?

Think in a similar fashion like:
1. The bare name of an array is equivalent with the pointer to the first element, without the need to specify index 0.
2. toString() from Java makes it possible to use the name of an object as a string without calling any object method.

Now is there a way in C++ to use the name of a class object to refer to its first member? Consider:

class Program
{
public:
    int id;
    char *str;
};

void function(int p)
{
//...
}

and then:

Program prog0;
function(prog0); // instead of function(prog0.id)

Any way to "hide" the member reference?
EDIT:
Why was the holyBlackCat's answer deleted? I was inclining to vote it as the best answer -- no offense, Mateusz. But he was the first to suggest conversion operator and the example was complete and simple.

Upvotes: 0

Views: 102

Answers (2)

Mateusz Grzejek
Mateusz Grzejek

Reputation: 12068

In C++, such behaviour would be a cataclysm. If I understand correctly, Java tries to convert object of type A to object of type B by searching for first member in A, that is of type B or is implicitly convertible to B.

C++ wasn't designed that way. We like to write code, that is always predictable. You can achieve what you want, but for a price.

The best solution in this case would be conversion operator - consider:

class Program
{
public:
  int id;
  char *str;

  operator int()
  {
    return this->id;
  }

  //You can have more than one!
  operator const char*()
  {
    return this->str;
  }
};

void function_int(int p)
{
}

void function_str(const char* s)
{
}

Now it is possible to do the following:

Program prog;
function_int(prog); //Equivalent of function_int(prog.id)
function_str(prog); //Equivalent of function_int(prog.str)

The price is, that if you add another int and place it before id it will not be used in conversion, because we stated in our operator explicitly, that "int content" of our class is represented by id and this member is considered when it comes to such conversion.

However, even this simple example shows some potential problems - overloading functions with integral and pointer types could result in very unpredictable behavior. When type contains conversion operators to both pointers and integers, it can get even worse.

Assume, that we have following function:

void func(unsigned long)
{
}

And we call func with argument of type Program. Which conversion operator would you expect to be called? Compiler knows how to convert Program to either int or const char*, but not unsigned long. This article on cppreference should help you to understand how implicit conversions work.

Also, as Barry pointed out, more meaningless constructs become available. Consider this one:

int x = prog + 2

What does it mean? It is perfectly valid code, though. That is why conversion operators should be dosed extremely carefully (in pre-C++11 era, there was a general advise, that every class should have at most one such operator).

Quote from MSDN:

If a conversion is required that causes an ambiguity, an error is generated. Ambiguities arise when more than one user-defined conversion is available or when a user-defined conversion and a built-in conversion exist.

Sometimes, simple solution to this problem is to mark conversion operator with explicit keyword, so you would need to change above calls to:

function_int((int)prog);
function_str((const char*)prog);

It is not as pretty as the previous form, but much safer. It basically means, that compiler is forbidden to perform any implicit conversion using operator marked as explicit. Very useful to avoid ambiguous calls, while still providing some flexibility in code - you can still very easily convert objects of one type to another, but you can be sure when and where these conversions are performed.

However, explicit conversion operators are still not supported by some compilers, as this is C++ 11 feature (for example, Visual C++ 11 doesn't support it).

You can read more about explicit keyword here.

Upvotes: 5

Barry
Barry

Reputation: 303307

Now is there a way in C++ to use the name of a class object to refer to its first member?

No, C++ doesn't have any reflection, so there's no way to actually determine what the "first member" is.

However, if what you really want is to get an ID for any object, you could just require that object to have that method:

template <typename T>
void function(const T& t) {
    int id = t.getID();
    // etc.
}

Without knowing more about your use-case, it's hard to know what to propose.

Upvotes: 0

Related Questions