Thread: Finding length of char **

You count them. More specifically, your stringSplit function has to count them and tell you how many there are. ETA: There is no way to tell, just given a char **, how much memory is allocated at that spot; so whoever malloc's has to pass that information.

I don't know what you're trying to do, but consider ending your char** with a null string to mark as a terminator. for example:

Code:

char ** stringSplit(char * string, char delimiter, int* number)
{
  int x;
  char** test=(char **)malloc(4*sizeof(char*));
  test[0]="Line 1";
  test[1]="Line 2";
  test[2]="Line 3";
  test[3]=NULL;
  for(x = 0; *test; test++, x++);
  *number=x;
  return(test);
}

If you want to look into strtok, you can look into my own strtok function. It's much better than the original in that in won't damage the input.
And also don't use implicit main: http://cpwiki.sourceforge.net/Implic...2a2eaeb5955006

Yeah, I hate the original strtok, so
Plus mine is more convenient. No need to split the string yourself

You dont return a "char**" instead pass a "char[][1024]" into one of the arguments.

Code:

#include <string.h>
#include <stdio.h>

int SplitString(const char* in, const char* tokens, char out[][1024], int outCount);

int main(int argc, char* argv[])
{

    char splitStrings[5][1024];
    //5 is the maximum number of strings the output array can hold
    int count = SplitString("Test|Hello|Blah", "|", splitStrings, 5);

    for(int i = 0; i < count; ++i)
        printf("&#37;s\n", splitStrings[i]);
    return 0;
}


int SplitString(const char* in, const char* tokens, char out[][1024], int outCount)
{
    char tempChar[0xFFFF];
    int count = 0;
    strncpy(tempChar, in, sizeof(tempChar));

    char* tok = strtok(tempChar, tokens);
    while(count < outCount && tok)
    {
        strncpy(out[count++], tok, sizeof(*out));
        tok = strtok(NULL, tokens);
    }

    return count;
}

Avoid that evil strtok function. This is easier and safer:

Code:

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <assert.h>

const char* strtokv2(const char* strToSearch, const char* strDelimiter);
const char* strtokv3(const char* strToSearch, const char* strDelimiter, char* pBuffer, size_t nBufferSize);

const char* strtokv2(const char* strToSearch, const char* strDelimiter)
{
	size_t nStrLength = strlen(strToSearch);
	size_t nDelLength = strlen(strDelimiter);
	const char* strEnd = strToSearch + nStrLength;
	const char* p = strToSearch;
	while (p < strEnd && *p == ' ') p++;
	while (p++ < strEnd)
	{
		if (*p == *strDelimiter)
		{
			bool bFound = true;
			if ((size_t)(strEnd - p) < nDelLength) // Length of remaining string - length of delimiter
			for (size_t i = 1; i < nDelLength; i++)
			{
				if (p[i] != strDelimiter[i])
				{
					bFound = false;
					break;
				}
			}
			if (bFound)
				return p;
		}
	}
	return NULL;
}

const char* strtokv3(const char* strToSearch, const char* strDelimiter, char* pBuffer, size_t nBufferSize)
{
	uint32_t nLength;
	char* pFound;
	if (!strToSearch) return NULL;
	pFound = (char*)strtokv2(strToSearch, strDelimiter);
	if (!pFound)
		nLength = strlen(strToSearch) + 1; // +1 for NULL
	else
		nLength = (pFound - strToSearch) + 1; // +1 for NULL
	assert(nBufferSize >= nLength);
	memcpy(pBuffer, strToSearch, nLength - 1);
	pBuffer[nLength - 1] = 0;
	if (pFound)
		return pFound + 1;
	else
		return pFound;
}

int main (void)
{
	char str[] = "This is a test string";
	char mytokenizedstr[50][20] = {0};
	int index = 0;
	const char* pSearchPos = str;

	while ( (pSearchPos = strtokv3( pSearchPos, " ", mytokenizedstr[index], sizeof(mytokenizedstr[index]) )) != NULL ) index++;
	for (int i = 0; i < 5; i++)
		puts(mytokenizedstr[i]);
	puts(str);
	return 0;
}

Heres mine:

Code:

bool StrTok(const char* in, const char* tokens, int* index, char* out, size_t outLen)
{
    const char* ptr = &in[*index];
    if(*ptr && outLen)
    {
        size_t len = strcspn(ptr, tokens);
        size_t outSize = len < outLen-1 ? len : outLen-1;
        strncpy(out, ptr, outSize);
        out[outSize] = 0;
        *index += len + (ptr[len] != 0);
        return true;
    }
    return false;
}

const char myString[] = "dasd|ds";
int main(int argc, char* argv[])
{
    char buffer[1024];
    int index = 0;

    while(StrTok(myString, "|", &index, buffer, sizeof(buffer)))
        printf("&#37;s\n", buffer);
    
    return 0;
}