Re: Two versions of generic functions?

From:

Victor Bazarov <v.Abazarov@comAcast.net>

Newsgroups:

comp.lang.c++

Date:

Tue, 13 Apr 2010 16:36:48 -0400

Message-ID:

<hq2kli$gqh$1@news.datemas.de>

Immortal Nephi wrote:

On Apr 13, 2:55 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:

Immortal Nephi wrote:

On Apr 13, 1:10 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:

Immortal Nephi wrote:

   I create generic class. Non-unicode string and unicode string
definitions are placed in generic class body. I am unable to place
them into function body. I will have to create two separate
functions. Both functions behave the same.
   First version of function is non-unicode and second version of
function is unicode. Both functions take too much spaces in the
source code. It would be nice to have only one function.
   How do I declare local type variable into function body? Local type
variable will be string and wstring. The C++ Compiler will fail to
compile and error message says redefinition sampleText variables.
template< typename A, typename B, typename C >
class Foo
{
public:
   Foo() {}
   ~Foo() {}
   void Print( A a, B &b, C &c );
   static const A text;
   static const A text2;
};
const std::string Foo< std::string, std::ostream, std::istream >::text
=
   "Non-unicode --> Type your name: ";
const std::wstring Foo< std::wstring, std::wostream, std::wistream

::text =

L"Unicode --> Type your name: ";
const std::string Foo< std::string, std::ostream, std::istream

::text2 =

"\n\nNon-unicode --> Your name is ";
const std::wstring Foo< std::wstring, std::wostream, std::wistream

::text2 =

   L"\n\nUnicode --> Your name is ";
template< typename A, typename B, typename C >
void Foo< A, B, C >::Print( A a, B &b, C &c )
{
   A sampleText;
   std::string sampleText = ?Non-unicode string?;
   std::wstring sampleText = L?Unicode string?; // error redefinition

Isn't your 'A' type the type you need to declare 'sampleText'? If so,
use it:
      A sampleText;
Since you want to initialize it here, you need a helper class that would
contain that string in its static member, something like
   template<class ST> struct FooHelper {
       static const ST str;
   };
   std::string const FooHelper<std::string>::str("narrow");
   std::wstring const FooHelper<std::wstring>::str(L"wide");
    ...
   template<typename A ...> void FOO<A,B,C>::Print(...
      A sampleText = FooHelper<A>::str;

str variable is initialized in the global scope outside the function
body. I want the data to be initialized into str inside function
body.

You don't like a helper object, that's fine. Create *two* overloaded
functions that simply return your literals:

std::string FooHelper(std::string const&) { return "narrow"; }
std::wstring FooHelper(std::wstring const&) { return L"wide"; }

You can make them static in your class if you like.

Print(?.)
{
FooHelper<A>::str = ??;
FooHelper<A>::str = L??;

Remove those.

A sampleText = FooHelper<A>::str;

Change to

A sampleText = FooHelper(A());

c >> sampleText;
}
Type c will select either cin or wcin.

Why do you need to initialize the string you're reading into, anyway?

I already created two overloaded functions.

Which ones? I didn't see any. You only mentioned them, but you didn't
post their bodies, not even declarations.

> I wrote first version of

function. I used copy-paste to copy all my codes in its function body
to second version of function. I rename to add prefix ?w? to cout,
cin, string, and stringstream.
The duplicated second version of function takes too much spaces in my
source code. It seems unnecessary. I thought that I prefer to use
only one function.
You suggested FooHelper. You placed it in the file scope outside Foo
class definition.

Uh... Yes. Your class is called 'Foo'. I suggested a class FooHelper,
which you didn't like. Forget the class, just have two functions
instead. No, you don't like that either!

> I am trying to place it inside member function

body.

Well, define a local class, then. What's stopping you? Place two
functions 'FooHelper' in that local class, overload them. Of course
those are going to be duplicated since they will be instantiated along
with the member, but you probably don't care.

> The local variables are restricted in one member function only.

It looks like below.

A sampleText;
std::string sampleText = ?Hello World!?; // non const string
std::wstring sampleText = L?Hello World!?; // non const string

A sampleText2;
std::string sampleText2?; // uninitialized variable
std::wstring sampleText2; // uninitialized variable

What are you suggesting me to do?

I've made many suggestions that you seem to dislike. Well, I suggest
you go figure it out yourself, then.

Can FooHelper be in member function body?

Yes, in a local class. I am *not* going to spell it out. Your
homework, *you* do it. OK?
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask