Thread: Working directory pragma

I know that there is a defined macro called "__FILE__", which returns the source's filename with path.

Not necessarily. On many compilers, yes, that is what it contains; but I'm pretty sure that the preprocessor can stick just the file name into there if it wants to, without the path.

Why do you need to do this? You probably don't need it to reference other files: most of the time, you can get away with relative directory paths. For example:

Code:

#include "header.h"
#include "./header.h"
#include "../header.h"
#include "test/header.h"
#include "../othertest/header.h"
#include "../../../this/and/that/header.h"

std::ifstream file("header.h");
std::ifstream file2("./header.h");
std::ifstream file3("../../this/header.h");

I know I can probably solve this using substrings with a String class, but in my case I have to use it for a #define.

Why not just use something like this?

Code:

const char *get_folder_name() { /* ... */ }

Is there a particular reason you need a #define?

To answer your question, I don't know how to do this at compile-time -- but you can do it at runtime with something like this:

Code:

const char *get_folder_name() {
    static char fullpath[] = __FILE__, *p;
    if((p = strrchr(fullpath, '\\'))) *p = 0;
    return fullpath;
}

Or, to handle slashes and backslashes, you could make use of strpbrk(). (I think that's the one. Maybe it was strspn().)

I have been programming professionally for over 20 years, and I have yet to find a need to know which directory the source file is in within my source code. In fact, I can't really think what purpose it would serve to know this.

Can you enlighten me to what the use of this is?

By the way, I'm pretty sure that there are various variables in Visual Studio that you can use in the Project Properties to create a compiler define (-Dsomename=$CurrentDir or some such).

--
Mats

> #include "other\\some_other_file.h"
This will be relative to the directory of the current source file.

> #pragma comment (lib, "other\\some_lib.lib")
This is probably going to be relative to the project directory (I guess), that is where your project file is.

I generally dislike the #pragma approach for specifying which libraries to link against as being inflexible and unportable, and now also for being ambiguous.

IMO, it is far better to use the project settings to specify where your libraries are, and what the names of the libraries are. Then your source code can be nice and clean, and refer only to those things which matter to the compiler, and not the linker.

The #pragma approach works well if you have a single massive source file which needs one or two libraries, and you don't want to go to the trouble of making a separate project.

By the way, the #line directive can set __FILE__ to any arbitrary string the programmer wants, so it's not exactly reliable.