Replacing 'strcpy' with 'strcpy_s' for dynamic string

[RavindraB]

I am migrating C++ code to VS2005, for this i have to replace the some Deprecated CRT Functions like “strcpy” by strcpy_s

I have written template to replace the function call. For strcpy_s I need to pass destination buffer size. This is possible for statically allocated string but not working for dynamically memory allocated strings as can’t determine size of the buffer at compile time.

The code which I had written is as below,

template <class T>

errno_t SafeStrCopy (T* szDest, const T* szSrc)

{     
        return strcpy_s(szDest,sizeof(szDest),szSrc);       

}  

#define strcpy SafeStrCopy 

Void main ()

{

      char sz_Dest[20] = "Hello World";

       char sz_Source[20]= "";

       char* dynStr = new char[20];

      strcpy(sz_StrTo,sz_StrFrom); //This works fine as it’s static 

      strcpy(dynStr,sz_StrFrom); //Doesn’t work as it’s dynamic
}

So can we write a single template which will work for both of these cases..?

[Banfa]

So can we write a single template which will work for both of these cases..?

No, in fact you will never be able to get a function like this working for a dynamically allocated string without passing the size of the string because all the code has to go on is the type of a the variable and for a dynamically allocated string that is a pointer.

strcpy is not deprecated, Microsoft say so but they do not write the C/C++ standards, on some *nix platforms strcpy is replaced by strlcpy.

The truth is that strcpy does have some security issues (through the risk of buffer over-run) and MS have created the language extension strcpy_s while other have created strlcpy, however neither has made it into the C/C++ standard (as far as I am aware) so far although there is a good case for doing so.

[RavindraB]

Thanks for guidelines, we are following same approch..

My next questions are came up while I investigating on templates..
What is the difference between following two templates

template <class T>

T& strcpy1(T &tParam1, T &tParam2)

{

strcpy_s(tParam 1, sizeof(tParam2) , tParam2);

return tParam1;

}

template <class T>

T strcpy1(T *tParam1, T *tParam2)

{

strcpy_s(tParam 1, sizeof(tParam2) , tParam2);

return *tParam1;

}


Another question is also about template.
I found the template code as below,


template <int CCH>

inline HRESULT SafeStrCopy(cha r (&szBuffer)[CCH], const char *szStr)

{

C_ASSERT(CCH > 0);

return StringCchCopy(s zBuffer, CCH, szStr);

}

Here its determine array size in CCH field, through “char &szBuffer)[CCH]”

But not cleared well to me.

How compiler calls this template when it invokes strcpy(sz_StrTo ,sz_StrFrom);

Though it seems from template decalration that we need to pass arg as int ..?

What is difference between

template <int CCH> and template <class T> declarations?

[Banfa]

What is the difference between following two templates

template <class T>

T& strcpy1(T &tParam1, T &tParam2)

{

strcpy_s(tParam 1, sizeof(tParam2) , tParam2);

return tParam1;

}

template <class T>

T strcpy1(T *tParam1, T *tParam2)

{

strcpy_s(tParam 1, sizeof(tParam2) , tParam2);

return *tParam1;

}

The first declares a function that takes reference arguments the second a function that takes pointer arguments. The correct operation depends entirely on what the compiler chooses to use for class T.

template <int CCH>

inline HRESULT SafeStrCopy(cha r (&szBuffer)[CCH], const char *szStr)
{
C_ASSERT(CCH > 0);

return StringCchCopy(s zBuffer, CCH, szStr);
}

Here its determine array size in CCH field, through “char &szBuffer)[CCH]”

But not cleared well to me.

How compiler calls this template when it invokes strcpy(sz_StrTo ,sz_StrFrom);

Though it seems from template decalration that we need to pass arg as int ..?

What is difference between

template <int CCH> and template <class T> declarations?

Careful, template parameters are not arguments. Since sz_StrTo and the function takes a reference to an array of size CCH the compiler can work out the value of CCH required to call the function with sz_StrTo. Alterntitively it is possible that this template was always used with explicit values for it template parameters rather than trying to let the compiler work it out.

The difference between template <int CCH> and template <class T> is that the first declares a template with a generic value and the second declares a template with a generic type.