memory functions

[zwA4jE8b]

I have been working with memory functions and I believe the reason a char* is used is because it is one byte in size. Is that correct?

Also, because char* is being used, will it work for any 1 byte section of memory, no matter what is stored at that address?

//Michael Ervin - Memory Functions
//Original work for memcpy at:
//http://www.koders.com/c/fidF24F0269D2BB87CADB58636E7626C3D090150BD8.aspx

#ifndef H_MEMFUNCS
#define H_MEMFUNCS

class memfuncs
{
	void* memc0py(void* _dst, void* _src, size_t _sz);
	void* mems3t(void* _dst, int _set, size_t _sz);
	int memc0mp(void* _left, void*_right, size_t _sz);
};

//Copies a block of memory of _sz bytes
void* memc0py(void* _dst, void* _src, size_t _sz)
{
	char* _d = (char*)_dst;
	char* _s = (char*)_src;
	while (_sz-- > 0){*_d++ = *_s++;}
	return _dst;
}

//Sets a block of memory to value of _set
void* mems3t(void* _dst, int _set, size_t _sz)
{
	char* _d = (char*)_dst;
	while(_sz-- > 0){*_d++ = _set;}
	return _dst;
}

//Return 1 if (==), Return 0 if (!=)
int memc0mp(void* _left, void*_right, size_t _sz)
{
	char* _l = (char*)_left;
	char* _r = (char*)_right;
	while(_sz-- > 0){
		if (*_l++ != *_r++)
			return 0;}
	return 1;
}
#endif 

[3hM2Nwbp]

If you're planning on using those methods in C++, be careful not to overwrite protected regions of classes (like v-tables). The methods may also not have the expected effect on floating point values. (You might also consider placing those warnings in the relevant documentation to your end-users.)

[zwA4jE8b]

oh this is not for end users. I am a novice programmer and just practicing.

Do you know the answer for this...
...Also, because char* is being used, will it work for any 1 byte section of memory, no matter what is stored at that address?

So far I have had luck with double and floats. I have tried different numbers with decimal places and get correct results. As long as I enter the correct size_t for the datatype I am using.

[helios]

It should be noted that the functions defined from line 16 onwards and the functions declared between lines 10-12 are not the same.

Also, because char* is being used, will it work for any 1 byte section of memory, no matter what is stored at that address?

For some definitions of "work", yes. For example, if by "work" you mean "replace the contents with something that won't make the program crash at some point", then no, it won't "work" for every valid input ("valid" meaning a set of parameters that reference memory that the program is allowed to modify).

[zwA4jE8b]

what do you mean that they are not the same?

Should I just leave off the functions prototypes?

And I know it doesn't work with strings. I have tested it with chars, ints, double, floats, longs and have recieved good results so far.

[helios]

I mean the declared functions are member functions, and the defined functions are global functions.

[Computergeek01]

I'm just curious, I know you said you were a novice but you seem to have some skill in the subject, why is this written in C? The whole taking void pointers as arguments and explicitly casting them within the next couple of lines is pretty old school, with a handful of changes you could use templates.

[zwA4jE8b]

@helios
I thought that was how it needed to be setup. But now that you have pointed it out, I understand why I do not need the class. Thanks.


@computergeek01
templates are going to be next . When I was researching this, as pointed in the hyperlink, I practically copied the memcpy function, and based my others off of that (that isn't to say that I do not understand it). The original source is written in C.

I was thinking...

template <class dType>
dType* mems3t(dType* _dst, dType* _src, size_t _sz)

EDIT: I do like the void* char* cast because it allows me to work byte by byte.
Although I am sure there is another way, I do not yet know it though


Sample Run:

#include <iostream>
#include <string>
#include "memfuncs.h"

using namespace std;

int main()
{
	cout.precision(10);
	double x = 5.5763219;
	double y;
	char a[] = {'A', 'B', '1', NULL};
	char b[4];

	memc0py(&y, &x, 8);
	cout << y << endl;
	memc0py(&b, &a, 4);
	cout << b << endl;
	cout << memc0mp(&a, &b, 1) << endl;
	mems3t(&b, '-', 1);
	cout << b << endl;
	cout << memc0mp(&a, &b, 1) << endl;
	cin.get();
	return 0;
}

5.5763219
AB1
1
-B1
0