templates in parameters

[ssylee]

I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).
Would I call the function like as follows:

MyType p = ConvFunc <RECT(rectangle);

when rectangle is of type RECT?

[Victor Bazarov]

ssylee wrote:

I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).

Post it here. Don't make people go to some unknown web site,
potentially full of who knows what...

Would I call the function like as follows:

MyType p = ConvFunc <RECT(rectangle);

when rectangle is of type RECT?

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

[ssylee]

On Aug 1, 11:04*am, Victor Bazarov <[e-mail]:

ssylee wrote:

I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).

Post it here. *Don't make people go to some unknown web site,
potentially full of who knows what...

Would I call the function like as follows:

MyType p = ConvFunc <RECT(rectangle);

when rectangle is of type RECT?

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

Sorry for the inconvenience. I was trying to make it easier to read
(as I don't know how to use code tags here [if i can use code tags
here]).

template <class T>
// MyType is a struct
MyType ConvFunc(T input)
{
// conversion manipulation that has nothing to do with the
conversion
}

[mlimber]

On Aug 1, 1:53*pm, ssylee <[e-mail]:

I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).
Would I call the function like as follows:

MyType p = ConvFunc <RECT(rectangle);

when rectangle is of type RECT?

The code is:

struct MyType { /*...*/ };

template <class T>
MyType ConvFunc(T input)
{
// ...
}

You don't need to specify the type of a parameter (unless you perhaps
wanted a derived class to be converted to its base class or something)
since the compiler can deduce it automatically. If the return value
were customizable, then you would need to specify that since it is not
a function argument and therefore not deducible:

template<class Ret, class Arg>
Ret Conv( const Arg& arg )
{
// ...
}

void Foo( const int n )
{
MyType m1 = Conv( n ); // Error! Can't figure out return type
MyType m2 = Conv<MyType>( n ); // Ok
MyType m3 = Conv<MyType,int>( n ); // Ok but redundant
MyType m4 = Conv<MyType,double>( n ); // Ok, forces conversion
// ...
}

Cheers! --M

[ssylee]

On Aug 1, 11:14*am, mlimber <[e-mail]:

On Aug 1, 1:53*pm, ssylee <[e-mail]:

I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).
Would I call the function like as follows:

MyType p = ConvFunc <RECT(rectangle);

when rectangle is of type RECT?

The code is:

*struct MyType { /*...*/ };

*template <class T>
*MyType ConvFunc(T input)
*{
* * // ...
*}

You don't need to specify the type of a parameter (unless you perhaps
wanted a derived class to be converted to its base class or something)
since the compiler can deduce it automatically. If the return value
were customizable, then you would need to specify that since it is not
a function argument and therefore not deducible:

*template<class Ret, class Arg>
*Ret Conv( const Arg& arg )
*{
* *// ...
*}

*void Foo( const int n )
*{
* *MyType m1 = Conv( n ); *// Error! Can't figure out return type
* *MyType m2 = Conv<MyType>( n ); * * // Ok
* *MyType m3 = Conv<MyType,int>( n ); // Ok but redundant
* *MyType m4 = Conv<MyType,double>( n ); // Ok, forces conversion
* *// ...
*}

Cheers! --M

Thanks. I think you misunderstood what I'm trying to do. I'm trying to
convert the parameter (which could be in many different types) into
MyType. Would I need to use the power of templates to achieve the goal?

[Victor Bazarov]

ssylee wrote:

On Aug 1, 11:04 am, Victor Bazarov <[e-mail]:

>ssylee wrote:

>>I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).

Post it here. Don't make people go to some unknown web site,
potentially full of who knows what...

>>Would I call the function like as follows:
MyType p = ConvFunc <RECT(rectangle);
when rectangle is of type RECT?

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

Sorry for the inconvenience. I was trying to make it easier to read
(as I don't know how to use code tags here [if i can use code tags
here]).

template <class T>
// MyType is a struct
MyType ConvFunc(T input)
{
// conversion manipulation that has nothing to do with the
conversion
}

I am not sure what code tags are, sorry about making it inconvenient to
you. We post code here. Code is code, the alphabet is limited, the
numbers are common and the special symbols are in most cases don't need
to be tri- or di-graphed. Read the group and get the feel before
posting, it's never too late to learn the rules.

As for the function

template<class Tvoid foo(T t);

, you don't need to supply the template argument if your function
argument is already of that type, the compiler will take care of the
template argument deduction. If you do want to call a *different*
function with a particular argument, do supply it. If both are the
same, it won't matter. For, example, if I want to call my 'foo'
instantiated with 'unsigned' as its template argument, but supply an
integer, I would do

foo<unsigned>(42);

, for example. Since 42 is already an int, I don't have to write

foo<int>(42);

, IOW, it's the same as writing

foo(42); // compiler deduces T == int

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

[ssylee]

On Aug 1, 11:50*am, Victor Bazarov <[e-mail]:

ssylee wrote:

On Aug 1, 11:04 am, Victor Bazarov <[e-mail]:

ssylee wrote:
I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).
Post it here. *Don't make people go to some unknown web site,
potentially full of who knows what...

>Would I call the function like as follows:
MyType p = ConvFunc <RECT(rectangle);
when rectangle is of type RECT?
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

Sorry for the inconvenience. I was trying to make it easier to read
(as I don't know how to use code tags here [if i can use code tags
here]).

template <class T>
// MyType is a struct
MyType ConvFunc(T input)
{
* * * *// conversion manipulation that has nothing to do with the
conversion
}

I am not sure what code tags are, sorry about making it inconvenient to
you. *We post code here. *Code is code, the alphabet is limited, the
numbers are common and the special symbols are in most cases don't need
to be tri- or di-graphed. *Read the group and get the feel before
posting, it's never too late to learn the rules.

As for the function

* * *template<class Tvoid foo(T t);

, you don't need to supply the template argument if your function
argument is already of that type, the compiler will take care of the
template argument deduction. *If you do want to call a *different*
function with a particular argument, do supply it. *If both are the
same, it won't matter. *For, example, if I want to call my 'foo'
instantiated with 'unsigned' as its template argument, but supply an
integer, I would do

* * *foo<unsigned>(42);

, for example. *Since 42 is already an int, I don't have to write

* * *foo<int>(42);

, IOW, it's the same as writing

* * *foo(42); // compiler deduces T == int

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

Thanks for the clarification Victor. I thought the parameters are
different types, but after taking a closer look, they are the same
type.

[mlimber]

On Aug 1, 2:25*pm, ssylee <[e-mail]:

On Aug 1, 11:14*am, mlimber <[e-mail]:

On Aug 1, 1:53*pm, ssylee <[e-mail]:

I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).
Would I call the function like as follows:

MyType p = ConvFunc <RECT(rectangle);

when rectangle is of type RECT?

The code is:

*struct MyType { /*...*/ };

*template <class T>
*MyType ConvFunc(T input)
*{
* * // ...
*}

You don't need to specify the type of a parameter (unless you perhaps
wanted a derived class to be converted to its base class or something)
since the compiler can deduce it automatically. If the return value
were customizable, then you would need to specify that since it is not
a function argument and therefore not deducible:

*template<class Ret, class Arg>
*Ret Conv( const Arg& arg )
*{
* *// ...
*}

*void Foo( const int n )
*{
* *MyType m1 = Conv( n ); *// Error! Can't figure out return type
* *MyType m2 = Conv<MyType>( n ); * * // Ok
* *MyType m3 = Conv<MyType,int>( n ); // Ok but redundant
* *MyType m4 = Conv<MyType,double>( n ); // Ok, forces conversion
* *// ...
*}

Thanks. I think you misunderstood what I'm trying to do. I'm trying to
convert the parameter (which could be in many different types) into
MyType. Would I need to use the power of templates to achieve the goal?

I don't believe I misunderstood you. I answered your question in the
sentence after the first code block and then attempted to demonstrate
a more general case where a function Conv() could convert between any
objects. Note also that you could use an overloaded cast operator to
do a conversion if the result type is a class:

#include <sstream>

class A
{
int i_;
public:
// ...

// Convert an A to a string automatically
operator std::string() const
{
std::ostringstream oss;
oss << i_;
}
};

void Foo( const A& a )
{
// These all do the same thing
std::string s1 = a; // implicitly calls A::operator std::string()
std::string s2 = static_cast<std::string>( a ); // Explicit
std::string s3 = Conv<std::string>( a ); // Use the func above
// ...
}

Cheers! --M

[mlimber]

On Aug 1, 3:16*pm, mlimber <[e-mail]:

On Aug 1, 2:25*pm, ssylee <[e-mail]:

On Aug 1, 11:14*am, mlimber <[e-mail]:

On Aug 1, 1:53*pm, ssylee <[e-mail]:

I'm trying to template a function as follows in the pastebin
link(http://pastebin.com/m5e642c72).
Would I call the function like as follows:

MyType p = ConvFunc <RECT(rectangle);

when rectangle is of type RECT?

The code is:

*struct MyType { /*...*/ };

*template <class T>
*MyType ConvFunc(T input)
*{
* * // ...
*}

You don't need to specify the type of a parameter (unless you perhaps
wanted a derived class to be converted to its base class or something)
since the compiler can deduce it automatically. If the return value
were customizable, then you would need to specify that since it is not
a function argument and therefore not deducible:

*template<class Ret, class Arg>
*Ret Conv( const Arg& arg )
*{
* *// ...
*}

*void Foo( const int n )
*{
* *MyType m1 = Conv( n ); *// Error! Can't figure out return type
* *MyType m2 = Conv<MyType>( n ); * * // Ok
* *MyType m3 = Conv<MyType,int>( n ); // Ok but redundant
* *MyType m4 = Conv<MyType,double>( n ); // Ok, forces conversion
* *// ...
*}

Thanks. I think you misunderstood what I'm trying to do. I'm trying to
convert the parameter (which could be in many different types) into
MyType. Would I need to use the power of templates to achieve the goal?

I don't believe I misunderstood you. I answered your question in the
sentence after the first code block and then attempted to demonstrate
a more general case where a function Conv() could convert between any
objects. Note also that you could use an overloaded cast operator to
do a conversion if the result type is a class:

*#include <sstream>

*class A
*{
* *int i_;
*public:
* *// ...

* *// Convert an A to a string automatically
* *operator std::string() const
* *{
* * *std::ostringstream oss;
* * *oss << i_;

Forgot:

return oss.str();

* *}
*};

Cheers! --M