copy content of vector<BYTE> to BYTE*

[Vince]

Hi,

I have replaced my BYTE* by a vector<BYTE> and before I used to do :

void CCardRecord::Ge tRecData(int nOffset, int nDataSize, CString& csValue)
{
BYTE *pTmp = NULL;
pTmp = new BYTE[nDataSize + 1];
memset(pTmp, 0, nDataSize + 1);
//memcpy(pTmp, &m_pData[ nOffset ], nDataSize);
csValue = pTmp;
}

But now m_pData is a vector.

[Victor Bazarov]

Vince wrote:

I have replaced my BYTE* by a vector<BYTE> and before I used to do :

void CCardRecord::Ge tRecData(int nOffset, int nDataSize, CString& csValue)
{
BYTE *pTmp = NULL;
pTmp = new BYTE[nDataSize + 1];
memset(pTmp, 0, nDataSize + 1);
//memcpy(pTmp, &m_pData[ nOffset ], nDataSize);
Nothing changes, really. You should still be able to do

memcpy(pTmp, &m_pData[nOffset], nDataSize);

The reason is that vector's storage is a contiguous chunk of elements,
essentially an array. 'm_pData[nOffset]' does call the operator[] for the
vector, but it returns a reference to the nOffset-th element, and you may
take its address. All elements of the vector after the nOffset-th sit in
the same array, so you may pass it to 'memcpy'.
csValue = pTmp;
}

But now m_pData is a vector.

V

[Vince]

d:\RATP\Borne_F ROM_SCRATCH_200 105\CardObj.cpp (159): error C2440: '=' :
cannot convert from 'std::vector<_T y>' to 'BYTE *'
with
[
_Ty=BYTE
]
"Victor Bazarov" <v.********@com Acast.net> a écrit dans le message de news:
5u************* *****@newsread1 .mlpsca01.us.to .verio.net...

Vince wrote:

I have replaced my BYTE* by a vector<BYTE> and before I used to do :

void CCardRecord::Ge tRecData(int nOffset, int nDataSize, CString&
csValue)
{
BYTE *pTmp = NULL;
pTmp = new BYTE[nDataSize + 1];
memset(pTmp, 0, nDataSize + 1);
//memcpy(pTmp, &m_pData[ nOffset ], nDataSize);

Nothing changes, really. You should still be able to do

memcpy(pTmp, &m_pData[nOffset], nDataSize);

The reason is that vector's storage is a contiguous chunk of elements,
essentially an array. 'm_pData[nOffset]' does call the operator[] for the
vector, but it returns a reference to the nOffset-th element, and you may
take its address. All elements of the vector after the nOffset-th sit in
the same array, so you may pass it to 'memcpy'.

csValue = pTmp;
}

But now m_pData is a vector.

V

[Victor Bazarov]

Vince wrote:

d:\RATP\Borne_F ROM_SCRATCH_200 105\CardObj.cpp (159): error C2440: '=' :
cannot convert from 'std::vector<_T y>' to 'BYTE *'
with
[
_Ty=BYTE
]
WHERE? There is no assignment in your code fragment except to 'csValue'
and 'pTmp', none of which is a vector.

You said 'm_pData' was a vector. Is it? Or is it a pointer to a vector?
Did you leave the rest of the function intact? Did you change it? If you
did change it, how?

And don't top-post, please. Thank you.


"Victor Bazarov" <v.********@com Acast.net> a écrit dans le message de news:
5u************* *****@newsread1 .mlpsca01.us.to .verio.net...

Vince wrote:

I have replaced my BYTE* by a vector<BYTE> and before I used to do :

void CCardRecord::Ge tRecData(int nOffset, int nDataSize, CString&
csValue)
{
BYTE *pTmp = NULL;
pTmp = new BYTE[nDataSize + 1];
memset(pTm p, 0, nDataSize + 1);
//memcpy(pTmp, &m_pData[ nOffset ], nDataSize);

Nothing changes, really. You should still be able to do

memcpy(pTmp, &m_pData[nOffset], nDataSize);

The reason is that vector's storage is a contiguous chunk of elements,
essentially an array. 'm_pData[nOffset]' does call the operator[] for the
vector, but it returns a reference to the nOffset-th element, and you may
take its address. All elements of the vector after the nOffset-th sit in
the same array, so you may pass it to 'memcpy'.

csValue = pTmp;
}

But now m_pData is a vector.

V

--
Please remove capital As from my address when replying by mail

[Vince]

"Victor Bazarov" <v.********@com Acast.net> a écrit dans le message de news:
GD************* ******@newsread 1.mlpsca01.us.t o.verio.net...

Vince wrote:

d:\RATP\Borne_F ROM_SCRATCH_200 105\CardObj.cpp (159): error C2440: '=' :
cannot convert from 'std::vector<_T y>' to 'BYTE *'
with
[
_Ty=BYTE
]

WHERE? There is no assignment in your code fragment except to 'csValue'
and 'pTmp', none of which is a vector.

You said 'm_pData' was a vector. Is it? Or is it a pointer to a vector?
Did you leave the rest of the function intact? Did you change it? If you
did change it, how?

And don't top-post, please. Thank you.

"Victor Bazarov" <v.********@com Acast.net> a écrit dans le message de
news: 5u************* *****@newsread1 .mlpsca01.us.to .verio.net...

Vince wrote:

I have replaced my BYTE* by a vector<BYTE> and before I used to do :

void CCardRecord::Ge tRecData(int nOffset, int nDataSize, CString&
csValue)
{
BYTE *pTmp = NULL;
pTmp = new BYTE[nDataSize + 1];
memset(pTmp , 0, nDataSize + 1);
//memcpy(pTmp, &m_pData[ nOffset ], nDataSize);

Nothing changes, really. You should still be able to do

memcpy(pTmp, &m_pData[nOffset], nDataSize);

The reason is that vector's storage is a contiguous chunk of elements,
essentiall y an array. 'm_pData[nOffset]' does call the operator[] for
the
vector, but it returns a reference to the nOffset-th element, and you may
take its address. All elements of the vector after the nOffset-th sit in
the same array, so you may pass it to 'memcpy'.
csValue = pTmp;
}

But now m_pData is a vector.

V

--
Please remove capital As from my address when replying by mail

It is located somewhere else :

BYTE* pData = NULL;
map<int, CCardFile>::ite rator itFile = NULL;
map<int, CCardRecord>::i terator itRec = NULL;
for ( itFile = m_FileIndex.beg in(); itFile != m_FileIndex.end (); ++itFile )
{
for (itRec = itFile->second.m_RecIn dex.begin(); itRec !=
itFile->second.m_RecIn dex.end(); ++itRec)
{
nSFID = itFile->first;
nRecNo = itRec->second.m_nRecN o;
nRecLen = itRec->second.m_nRecL en;
pData = itRec->second.m_ByteA rray;
bRet = m_pCardReader->ReadRecord((BY TE)nSFID, (BYTE)nRecNo, pData, nRecLen);
if ( ! bRet )
return bRet;
}
}

[Victor Bazarov]

Vince wrote:

"Victor Bazarov" <v.********@com Acast.net> a écrit dans le message de news:
GD************* ******@newsread 1.mlpsca01.us.t o.verio.net...

Vince wrote:

d:\RATP\Born e_FROM_SCRATCH_ 200105\CardObj. cpp(159): error C2440: '=' :
cannot convert from 'std::vector<_T y>' to 'BYTE *'
with
[
_Ty=BYTE
]
WHERE? There is no assignment in your code fragment except to 'csValue'
and 'pTmp', none of which is a vector.

You said 'm_pData' was a vector. Is it? Or is it a pointer to a vector?
Did you leave the rest of the function intact? Did you change it? If you
did change it, how?

And don't top-post, please. Thank you.

[...]

It is located somewhere else :

BYTE* pData = NULL;
map<int, CCardFile>::ite rator itFile = NULL;
map<int, CCardRecord>::i terator itRec = NULL;
for ( itFile = m_FileIndex.beg in(); itFile != m_FileIndex.end (); ++itFile )
{
for (itRec = itFile->second.m_RecIn dex.begin(); itRec !=
itFile->second.m_RecIn dex.end(); ++itRec)
{
nSFID = itFile->first;
nRecNo = itRec->second.m_nRecN o;
nRecLen = itRec->second.m_nRecL en;
pData = itRec->second.m_ByteA rray;
I suppose I have to guess again, don't I? What's wrong? Couldn't you
somehow mark the line to which the error message relates?

Anyway, you made m_ByteArray a vector<BYTE>, right? Well, you need to
fix the rest of your code to reflect that. In particular, here you can
probably do

pData = & (itRec->second.m_ByteA rray[0]);
bRet = m_pCardReader->ReadRecord((BY TE)nSFID, (BYTE)nRecNo, pData, nRecLen);
if ( ! bRet )
return bRet;
}
}

But in any case, I strongly recommend you to rethink the implementation of
all your functions. For example, you probably don't need 'm_nRecLen' any
more because the vector keeps its own size. And so on...

Victor

[gMorphus]

Indeed it would work, although, the right way to do it, if you are
working with STL is to use the "copy" function.
For example:
vector < BYTE > Vect;
copy(Vect.begin ()+nOffset, Vect.begin()+nO ffset+nDataSize , pTmp);

Now let's complicate it.
Assuming you to replace the "vector" with a "list".
The copy fucntion receives 3 iterators so it is only logical we can use
list.
But, the with a list iterator we cannot use the '+' operator, so we
will operator overloading:

typedef list<BYTE> tSequent;
tSequent::itera tor operator+(tSequ ent::iterator it, int n)
{
for (int i=0; i<n; ++i) {
it++;
}
return it;
}

Now we don't even have to change our function. We can still use this
sentence:
copy(Vect.begin ()+nOffset, Vect.begin()+nO ffset+nDataSize , pTmp);

only Vect is a "list"...

P.S.
Effiency: using a vector is a lot more efficient. Using the copy
function with a vector instead the memcpy is a lot _less_ efficient.
The reason is that the copy function have to copy BYTE BYTE, as opposed
to coping the whole segment at once with the memcpy.

[Victor Bazarov]

gMorphus wrote:

[..] Effiency: using a vector is a lot more efficient. Using the copy
function with a vector instead the memcpy is a lot _less_ efficient.
The reason is that the copy function have to copy BYTE BYTE, as opposed
to coping the whole segment at once with the memcpy.

Actually, this all is not necessarily so. For all we know, 'std::copy'
can be specialised for vectors to perform memcpy under the covers...

[White Wolf]

gMorphus wrote:
[<<<snip]

Effiency: using a vector is a lot more efficient. Using the copy
function with a vector instead the memcpy is a lot _less_ efficient.
The reason is that the copy function have to copy BYTE BYTE, as opposed
to coping the whole segment at once with the memcpy.

Nothing whatsoever requires a standard vector of POD types to do so.

Also, counting the fact that the full implementation of std::copy is most
probably visible to the compiler, it is not too far fetched to assume that
in certain cases (if inlining happens) std::copy will beat the hell out of
memcpy in speed. Of course this is true as long as memcpy is not a compiler
intrinsic, in which case it may be so unpolitely fast that no code can be
faster. And of course, as Victor has pointed out, std::copy and memcpy can
just be the very same functions.

So in a short time we have given acceptable (or at least a tiny bit
convincing) arguments for std::copy being way slower than memcpy, way faster
than memcpy and the same as memcpy. Now I guess all we need is to remember
that Michael Jackson, who is not in jail and not on bail. Or Knuth. They
have placed the root of evil to a very different place than the current US
government. They were pointing out, that premature optimization is the root
of all evil. Which it may not be, but it surely is a damn dumb waste of
time guesswork to optimize code, wich has not been written yet, unknown if
it is slow or not, unknown what causes it to be slow if it is... It is as
reasonable spending of ones' time as me thinking about what should I wear on
my date with Claudia Schiffer.

Sorry for the (kinda) outburts, nothing personal. I just wanted to point
out that guesswork is evil. Especially if people believe it.

--
WW aka Attila
:::
Constant change is here to stay

[gMorphus]

Ok, after a little investigation I have realized that my solution is
not good.
That operator overlaoding wouldn't work for vector because the type
will be a "const unsigned char *" - which you cannot overload.

Moreover, I think the copy function _cannot_ be overloaded. The reason
for is the same - the vector iterator is simply a pointer, which you
cannot be overloaded or specialised.

Am I right?