Re: Two versions of generic functions?

From:

Victor Bazarov <v.Abazarov@comAcast.net>

Newsgroups:

comp.lang.c++

Date:

Tue, 13 Apr 2010 15:55:39 -0400

Message-ID:

<hq2i8c$e8j$1@news.datemas.de>

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?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask