Operator overloading.<\/p>\n
Looks great. Reduces verbosity.<\/p>\n
Until it doesn’t.<\/p>\n
Consider this overloaded function call operator:<\/p>\n
struct StorageLoader\r\n{\r\n template<typename DataType>\r\n DataType operator()(StorageOptions<DataType> const* options);\r\n};\r\n<\/pre>\nThe idea is that you can use the function call operator on a Storage\u00adLoader<\/code> object to load data from storage, using a StorageOptions<\/code> to describe how you want it to be loaded.<\/p>\nStorageOptions<Data1> data1Options;\r\ndata1Options.ignore_missing(true);\r\n\r\nStorageLoader storageLoader;\r\nData1 data1 = storageLoader(&data1Options);\r\n<\/pre>\nThe parameter is accepted as a pointer so you can pass nullptr<\/code> to indicate that you accept all defaults.<\/p>\n\/\/ Oops, this doesn't work.\r\nData1 data1 = storageLoader(nullptr);\r\n<\/pre>\nThe nullptr<\/code> doesn’t work because the compiler can’t read your mind to figure out which overload you’re trying to call. You have to help it along, either by refining the type of the parameter:<\/p>\nData1 data1 = storageLoader(static_cast<StorageOptions<Data1>*>(nullptr));\r\n<\/pre>\nor by explicitly specializing the function call operator.<\/p>\n
Data1 data1 = storageLoader.operator()<Data1>(nullptr);\r\n<\/pre>\nNeither of these is very attractive, and they certainly defeat any conciseness benefit of an overloaded operator.<\/p>\n
I personally am a fan of giving named function equivalents to overloaded operators, particularly if they are templated. In this case, I would have done something like<\/p>\n
struct StorageLoader\r\n{\r\n template<typename DataType>\r\n DataType Load(StorageOptions<DataType> const* options);\r\n\r\n template<typename DataType>\r\n DataType operator()(StorageOptions<DataType> const* options)\r\n { return Load(options); }\r\n};\r\n<\/pre>\nThe function call operator is just a convenient shorthand for calling the Load<\/code> method.<\/p>\n\/\/ Using function call operator\r\ndata1 = storageLoader(&data1Options);\r\n\r\n\/\/ Using named method\r\ndata1 = storageLoader.Load(&data1Options);\r\n\r\n\/\/ Named method works better for nullptr\r\ndata1 = storageLoader.Load<Data1>(nullptr);\r\n<\/pre>\nAnd then I can make the parameter to Load<\/code> default to nullptr<\/code>:<\/p>\nstruct StorageLoader\r\n{\r\n template<typename DataType>\r\n DataType Load(StorageOptions<DataType> const* options\r\n = nullptr<\/span>);\r\n\r\n ...\r\n};\r\n<\/pre>\nwhich allows you to write<\/p>\n
\/\/ If no parameters, then use default options\r\ndata1 = storageLoader.Load<Data1>();\r\n<\/pre>\n