Elysian Shadows

Ginto8 wrote:not to steal your thunder, but I realized some optimization could be made, and came up with this:

Code: Select all

const char* getFileExtension(const char* filename) {
    const char* tmp=strchr(filename,'.'),*ret = NULL;
    while(tmp) {
        ret = tmp;
        tmp = strchr(tmp+1,'.');
    }
    return ret?ret+1:NULL;
}

then if you wanted a separately allocated string, you could do this:

Code: Select all

char* extension = strdup(getFileExtension("blarg.txt"));

and it would allocate a string on the heap (same contents as what's returned by getFileExtension), which you would then later return with free().

avansc wrote:Well just to chime in.

you can go all silly and write it in all different ways.

something like

Code: Select all

char *stripExt(const char *file)
{
	int len = strchr(file,'.') - file;
	char *ret = (char*)calloc(sizeof(char), len+1);
	memcpy(ret, file, len);
	return ret;
}

1000000 calls takes 88.194000 ms as apposed to lots' that runs in like 101ms. that might as well be the same speed. since this function is hardly going to be called a million times.

If anything his is a bit better in terms of readability. ...anywho.

bnpph wrote:Don't put calloc in functions like that.
Have it pass a pointer and store the created string into it.


Also, the fastest method would be to just return the length of filename without extension, and then use that instead of returning a new string. You could replace it with null char if you want to.

bnpph wrote:

Code: Select all

char *stripExt(char* destination, const char *file)
{
   int len = strchr(file,'.') - file;
   strncpy(destination, file, len);
   return destination;
}

(might have errors - didn't test)

This is much better way. This function will work with any type of allocated memory, and is much less likely to have memory leaks. Try to avoid allocating (and not freeing them before function returns) inside functions that are not object oriented.

bnpph wrote:stdup is not ISO C and I don't agree with it.
All of string.h's functions are designed where they pass a destination pointer. They also require your destination is large enough to store the result.

If you want to do what you're doing, it would make more sense to create a new type (FILENAME) as typedef of char*, then rename your function "createFilenameFromFile" or something, and then add a "deleteFilename" function. This is how many libraries do it.

Or, you can use C++ and wrap it in a class. That would be even better.

void deleteFileName(FILENAME file)
{
    free(file);
    file = NULL;
}

char *copystring(const char *s)
{
	char	*b;
	b = malloc(strlen(s)+1);
	strcpy (b, s);
	return b;
}

/*
================
AllocBspFace
================
*/
bspface_t	*AllocBspFace( void ) {
	bspface_t	*f;

	f = malloc(sizeof(*f));
	memset( f, 0, sizeof(*f) );

	return f;
}

winding_t	*WindingFromDrawSurf( mapDrawSurface_t *ds ) {
	winding_t	*w;
	int			i;

	w = AllocWinding( ds->numVerts );
	w->numpoints = ds->numVerts;
	for ( i = 0 ; i < ds->numVerts ; i++ ) {
		VectorCopy( ds->verts[i].xyz, w->p[i] );
	}
	return w;
}

bnpph wrote: Anyway, it's all personal preference, so do whatever you like.

avansc wrote: Anyways, this is hardly important enough to worry about it, to each his own.