Absolut filangivelse -> relativ filangivelse

Jeg antager at du arbejder med den der Borland-builder alle snakker om, det kan jeg ikke give dig? Men jeg kan sige dig, at \"current working direktory angives ved: \".\". Den over dig er: \"..\" og underdirektoriet Allan\\Simonsen hedder: \".\\\\Allan\\\\Simonsen\" (bemærk \\\\ for en enkelt \\ i C++-strenge).

Da jeg ikke har din builder kan jeg ikke give dig meget andet end det, men det skulle vel i grunden også være rigeligt.

moykal

Desværre ikke. Ovenstående ved jeg godt. Problemet er egentlig at jeg ikke kan få fat i \"current working directory\" undtagen som:

C:\\PROGRA~1\\PROJEKT\\

Og det kan jo dække over både (for eksempel):

C:\\PROGRAMMER\\PROJEKT\\
C:\\PROGRAM FILES\\PROJEKT\\

Og det er derfor ikke lige til at finde ud af hvad den relative sti skal være. Hvis nogen kan fortælle mig hvordan jeg får fat på \"current working directory\" med lange filnavne, så skulle jeg nok selv kunne klare resten.

I de gamle dosdage var filnavnet jo den første parameter til programmet, men jeg kan ikke huske om det var med lange filnavne eller ej - og så aner jeg slet ikke hvordan jeg skal få fat på det i et windowsprogram, hvis det stadig fungerer på samme måde.

Hvad giver ::GetCurrentDirectory()?

--- Doc

GetCurrentDirectory
The GetCurrentDirectory function retrieves the current directory for the current process.

DWORD GetCurrentDirectory(
  DWORD nBufferLength,  // size of directory buffer
  LPTSTR lpBuffer      // directory buffer
);
Parameters
nBufferLength
[in] Specifies the length, in TCHARs, of the buffer for the current directory string. The buffer length must include room for a terminating null character.
lpBuffer
[out] Pointer to the buffer that receives the current directory string. This null-terminated string specifies the absolute path to the current directory.
Return Values
If the function succeeds, the return value specifies the number of characters written to the buffer, not including the terminating null character.

If the function fails, the return value is zero. To get extended error information, call GetLastError.

If the buffer pointed to by lpBuffer is not large enough, the return value specifies the required size of the buffer, including the number of bytes necessary for a terminating null character.

Requirements
  Windows NT/2000: Requires Windows NT 3.1 or later.
  Windows 95/98: Requires Windows 95 or later.
  Header: Declared in Winbase.h; include Windows.h.
  Library: Use Kernel32.lib.
  Unicode: Implemented as Unicode and ANSI versions on Windows NT/2000.

Ser godt ud, men jeg skal til eksamen imorgen og på juleferie i Jylland bagefter, så du må desværre have lidt tålmodighed med min respons :-)

Her er noget kode, der under Win2K er fint nok... skid på mit buffer check... men jeg får lange navne...

#include <windows.h>
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    unsigned int nBufferLength;
    cout << \"Enter buffer length: \";
    cin >> nBufferLength;

    char *pszBuffer = new char[nBufferLength];
    const DWORD dwBufferLength = ::GetCurrentDirectory(nBufferLength,
        pszBuffer);

    if (0 == dwBufferLength)
        cerr << \"Error: Use GetLastError() to check out, that the buffer length \"
            \"probably is too short\" << endl;
    else cout << \"Current directory is: \" << pszBuffer << endl;

    char c;
    cin >> c;

    delete[] pszBuffer;
    return 0;
}

Denne linie forstår jeg ikke (DWORD og ::)

const DWORD dwBufferLength = ::GetCurrentDirectory(nBufferLength, pszBuffer);

DWORD er blot et andet ord for en unsigned long, altså noget der er dobbelt så langt som et WORD - 16 bit integer.

:: anvendes blot til at angive, at du anvender \"den udgave af GetCurrentDirectory\", der findes i det globale namespace. Hvis namespaces ikke siger dig noget, så kig evt. i Stroustrup. Namespaces er en slags \"kasse\" hvori du kan gruppere funktioner, klasser etc. I C++ kan du jo \"override\" dvs. du kan godt have flere funktioner der hedder f:

void f(int x);
int f(double a,double b);

og det går jo meget godt, indtil der er en der skriver en \"f\" med samme signatur, dvs. samme parameter-liste (en forskel i retur-typen er ikke nok). Hvad gør man så?

namespace X {
  void f(int x);
  int f(double a,double b);
};

namespace Y {
  int f(double a,double b);
};
using namespace X;

int main(void) {
  int a;
  double x,y;

  a = 1;
  f(a); // Her behøver du ikke angive hvilken f,
        // du anvender, da compileren kan genkende
        // signaturen.
  x = y = 0.0;
  f(x,y); // Fejl - hvilken f?
  X::f(x,y); // Korrekt - jeg anvender X\'s f.
  Y::f(x,y); // Korrekt - jeg anvender Y\'s f.
  return 0;
};

Jeg er ikke lige sikker på om compileren vil fejle, da vi jo har skrevet using namespace X,
men jeg regner med at du fatter pointen.

Det er standard, at man derfor angiver f.eks. standard Windows API funktioner med ::, for ligesom at fortælle at det blot er en simpel C-funktion, der kaldes.

namespaces er også rare, hvis du nu f.eks. vil anvende to biblioteker, der har funktioner med samme signaturer:

a.h:
:
void Open(const char *szDetJegVilAabne);
:

b.h:
:
void Open(const char *szDetAndetJegVilAabne);
:

hvad gør du her i din egen C++-implemtenterings-fil, hvis begge biblioteker skal anvendes?

namespace A {
#include <a.h>
};
namespace B {
#include <b.h>
};

int main(void) {
  const char szNoget[] = \"Noget\";
  const char szNogetAndet[] = \"Noget andet\";

  A::Open(szNoget);
  B::Open(szNogetAndet);

  return 0;
};

rimeligt enkelt i grunden.

god fornøjelse

moykal

Takker