In my work's codebase, I see the following

class custom {
  auto set_data_type(custom_type_t type_t) -> custom & {
    // set some stuff
    // return *this;
  }
}

Why can't we simply just do

class custom {
  custom & set_data_type(custom_type_t type_t) {
    // set some stuff
    // return *this;
  }
}

What is the point of using auto in this case when you already know the return type and already wrote it out in the ->... place?

It seems auto would only be beneficial if it is used with decltype(arg) and where arg may have varying return types?

CodePudding user response：

I would say style.

Moreover, it allows to be consistent in any contexts,

• simple one (as this one),
• more useful ones ("complex" decltype(arg) , scoping (-> iterator instead of typename C::iterator)
• or required one (lambda).

CodePudding user response：

To me the most use of this feature is when you're using nested type when defining a function body in a cpp file:

class MyLongClassName
{
  using ANestedType = ...;

  ANestedType myFunction();
}

When you implement to function body, this syntax avoid some repetition:

MyLongClassName::ANestedType MyLongClassName::myFunction()
{ ... }

versus

auto MyLongClassName::myFunction() -> ANestedType
{ ... }