Thread: strcat (), argv[], general string trouble

First of all, I don't think you should be doing this. argv[x] is only guarenteed to be as long as it needs to be to hold the actual string afaik, so I wouldn't strcat() to it. The best idea is to malloc() together a string large enough to move everything to it. That should be the safest and smartest way to handle it.

As far as the error is concerned, looking at the code, I don't know what the issue is. As long as you're including string.h, it should be working fine, although your usage appears somewhat unorthodox.

Edit: Wait a second. Why are you declaring argc and argv as const? Especially if you have any plans of editing them at all.

I tried before to strcat to a new var, but still had trouble with this part:
char *path1;
path1=*argv[1];
I did not malloc it.
I'll change it back and try to compile it on Windows instead (of Mac OS X), just to see what happens.
Then I'll learn how to allocate memory.
Thanks.

Oh, why I made argc and argv[] const? Because that's what the tutorial on scanning a directory did, that I started with.

Code:

char *path1;
path1=*argv[1];

Absolutely wrong. You're taking a pointer and assigning it a char instead of an address of a char.

PHP is probably messing you up with the concept of buffers and properly allocating memory since it hides most of that I believe.

Like

Code:

char newFilename[100];
strcpy( newFilename, argv[1] );
strcat( newFilename, "/" );
strcat( newFilename, ep->d_name );

Here's an example program:

Code:

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

/*
	This program will take a dir as the first arg
	and a file name as the second arg and then
	open the file and print it to stdout.
*/

int main(int argc, char *argv[])
{
	int c = 0;
	char szSlash[] = "/";
	char *szFile = NULL;
	FILE *f = NULL;

	if(argc < 3)
	{
		printf("Usage: &#37;s <path> <file>\n", argv[0]);
		return 1;
	}
	
	szFile = malloc(strlen(argv[1]) + strlen(szSlash) + strlen(argv[2]) + 1);
	if(!szFile)
	{
		printf("Unable to allocate memory...\n");
		return 2;
	}
	strcpy(szFile, argv[1]);
	strcat(szFile, szSlash);
	strcat(szFile, argv[2]);
	
	f = fopen(szFile, "r");
	if(!f)
	{
		printf("Unable to open file \"%s\"...\n", szFile);
		return 3;
	}
	while((c = fgetc(f)) != EOF)
	{
		putchar(c);
	}
	fclose(f);
	free(szFile);

	return 0;
}

And yes, C is primitive, but extremely powerful.

Originally Posted by Salem

Like

Code:

#include <limits.h>
char newFilename[PATH_MAX];
strcpy( newFilename, argv[1] );
strcat( newFilename, "/" );
strcat( newFilename, ep->d_name );

If you use the above, it will be portable to most machines. As long as there is only one or a few arrays for this, it should be fine to not use malloc()/free() for allocating the memory.

PATH_MAX is guaranteed to be sufficiently large to hold "any" valid filename [although it is possible construct "valid" filenames or paths that exceed this length if you are using relative paths [e.g. something like "c:\windows\..\windows\..\windows\" could be made "infinitely long" and still valid of sorts- rare and completely solvable by removing the superfluous path content, although that may be a bit difficult to do].

--
Mats

But PATH_MAX isn't itself a portable concept (it appears nowhere in C99), though I do agree you should use such a constant if one is available.

Originally Posted by markjoe

This will be used to make a path for any file that matches search criteria, up to 1000 files. Although they only need to be accessed one at a time.

Regardless of what is which standard, as long as it works on Tru64UNIX, Windows, and Mac, it's good for me.

Thanks alot for the help fellas!

If Mac means MacOS X, rather than older MacOS versions, then I'm fairly sure it will work fine [not quite certain about Tru64UNIX - if that's the exception, just do

Code:

#ifndef PATH_MAX
#define PATH_MAX 1024
#endif

or something similar (1024 should be OK for all SANE cases of file/directory structures)].


You should of course CHECK that the size of the path becomes no longer than the maximum size, whatever way you determine the max size.

--
Mats