Programming

I want to create a message function to be used as follows

Code:

string s1 = "Hello";
string s2 = "World";

error_notify ("Hello", "World");
error_notify (s1, "World");
error_notify ("Hello", s2);
error_notify (s1, s2);

char* c1 = "Hello";
char* c2 = "Hello";
error_notify ("Hello", s2);
error_notify (c1, "World");

This is what I have tried but am getting lot of errors.

Code:

void  error_notify (
  const char*  brief_msg,
  const char*  detailed_msg
) {
  cerr << "\nRUNTIME ERROR!  " << brief_msg << endl << detailed_msg << endl;
}

void  error_notify (
  const string  brief_msg,
  const string  detailed_msg
) {
  cerr << "\nRUNTIME ERROR!  " << brief_msg << endl << detailed_msg << endl;
}

---------- Post updated at 05:49 PM ---------- Previous update was at 05:28 PM ----------

I am also getting confused whether to use

Code:

string
string&
const string
const string&

in the argument list

---------- Post updated at 06:16 PM ---------- Previous update was at 05:49 PM ----------

I am going to stick with

Code:

const string&

which should be ok

The '&' is just a 'silent pass by pointer reference compiler directive', efficient if you want to do less copying of a large object, and potentially allowing modification of the original since the called method has access to the original, not a copy. I call it silent (and have mixed feelings about it as a direction) because, unlike the C practice of explicit pass by pointer reference, this one is invisible when calls are instantiated unless you refer to the function/method declaration. Saving the programmer keystrokes and encouraging pass by reference but also improving the chances of programmer error.

Modifying the original passed by reference is a good segue into const, with is more often used in call declarations to say the called method cannot directly modify the original. Of course, if the called method can call a class method that modifies, that gets a bit thin -- it was more for primitives -- look but do not change. Using const on a declaration says that the initialized value is the only value, it can never be changed, so it can be copied freely, cached without worrying about having a stale copy, a bit like final, but once that was just JAVA. Java's final vs. C++'s const - Stack Overflow

Const can have either of two meanings with pointers, const pointer or pointer to const data: C++ Reference - Const Pointers - Cprogramming.com

Quick interview question -- what are the three meanings of static?

Which errors?

To begin with, you should consider this an error:

Code:

char* c1 = "Hello";

You're creating a mutable pointer into a constant memory block. It should be:

Code:

const char* c1 = "Hello";

When passing object in a read-only capacity, you should consider passing by const reference rather than copying. An object passed this way shows up as const, and you can only call const methods on the object.

A string can be constructed from a const char*.

Using the notion of const-correctness, and temporary string can be constructed from a const char*, you get:

Code:

void error_notify(const std::string &brief_msg, const std::string &detailed_msg)
{
	std::cerr << "\nRUNTIME ERROR!  " << brief_msg << ':' << detailed_msg << std::endl;
}