avoiding unnecessary allocations for temporaries, r-value destructor - c++

Question

I have a many, MANY strings that are almost never modified after creation and access times to them is not really a concern. I have to minimize the memory usage so I opted to writing a class instead of using std::string which has to hold extra data such as capacity and length to conform with the standard. This change resulted in reduction of ~%30 memory usage.
To achieve this, I have written a class just wraps C-style null-terminated strings internally and manages the buffer so the class just consists of a pointer data member and it provides enough interface to rarely access and work with it like std::string.
I would like to avoid boilerplate code and allow transparent conversions from std::string and to std::string. So can I avoid allocating/copying the data from std::string on edge cases such as when temporary is needed? Consider this:
class A {
public:
A(const char* p) : p_{std::strdup(p)} { }
~A() { free(p_); }
A& append(const A&);
private:
char* p_;
};
Now in the following code:
A a;
a.append("test");
A temporary object will be created, allocating and copying the data. Then it will be immediately destroyed. The question is, is there a way to avoid this without creating a version of every function such as A& append(const char*). I would also like to support the transparent conversions for std::string so it will automatically become 3 versions of each function.
What effects will the following approach have:
class A {
public:
A(const char* p) : p_{std::strdup(p)} { }
A(const char* p) &&
: p_{p} {
}
~A() { free(p_); }
~A() && { /* nothing */ }
A& append(const A&);
private:
char* p_;
};
If this does not work, what strategy can I apply to solve this problem?

Answer 1

What effects will the following approach have:
A(const char* p) &&
~A() &&
The most likely effect is compilation error, since standard doesn't allow ref-qualifiers on c/d-tor.
I recommend implementing A::c_str just like strings do, and use the following helper from a template:
template<class Str>
const char* c_str_help(const Str& str) {
return str.c_str();
}
const char* c_str_help(const char* str) {
return str;
}
class A {
// ...
const char* c_str() const { return p_; }
template<class Str>
A& append(const Str& str) {
const char* s = c_str_help(str);
// implement using const char* s
}
};
PS: I recommend using a unique_ptr<char, void(*)(void*)> instead of a bare pointer for much easier implementation.

Answer 2

A bit similar to user2079303's approach, with SFINAE so we don't hinder overload resolution:
namespace detail_A {
char const *getString(std::string const &str) {
return str.c_str();
}
char const *getString(char const *str) {
return str;
}
// More `getString`s as needed...
template <class T>
using enableString = decltype(getString(std::declval<T>()));
}
class A {
// ...
template <class T, class = detail_A::enableString<T>>
A &append(T const &str) {
char const *p = detail_A::getString(str);
std::cout << "Appending \"" << p << "\"\n";
return *this;
}
};
See it live on Coliru