Escreva um arquivo em um caminho específico em C ++

Eu tenho esse código que grava com sucesso um arquivo:

ofstream outfile (path); outfile.write(buffer,size); outfile.flush(); outfile.close(); 

buffer e tamanho estão ok no resto do código. Como é possível colocar o arquivo em um caminho específico?

Especifique o caminho completo no construtor do stream, isso pode ser um caminho absoluto ou um caminho relativo. (relativo a onde o programa é executado.

O destruidor de streams fecha o arquivo para você, fechamentos explícitos são MAIS prováveis ​​de introduzir erros (escrever depois que o arquivo é fechado).

 #include  #include  int main() { const char *path="/home/user/file.txt"; std::ofstream file(path); //open in constructor std::string data("data to write to file"); file << data; }//file destructor 

Note que você pode usar std :: string no construtor de arquivos em C ++ 11 e é preferível a um const char * na maioria dos casos.

Razão para postar outra resposta

Estou postando porque nenhuma das outras respostas cobre o espaço do problema.

A resposta à sua pergunta depende de como você consegue o caminho. Se você estiver construindo o caminho inteiramente dentro do seu aplicativo, veja a resposta do @James Kanze. No entanto, se você estiver lendo o caminho ou os componentes do caminho do ambiente em que seu programa está sendo executado (por exemplo, variável de ambiente, linha de comando, arquivos de configuração, etc.), a solução será diferente. Para entender o porquê, precisamos definir o que é um caminho.

Visão geral rápida de caminhos

Nos sistemas operacionais (que conheço), um caminho é uma cadeia de caracteres que está em conformidade com uma mini-linguagem especificada pelo sistema operacional e pelo sistema de arquivos (sistema abreviado). Caminhos podem ser fornecidos para funções IO em um determinado sistema para acessar algum recurso. Por exemplo, aqui estão alguns caminhos que você pode encontrar no Windows:

 \file.txt \\bob\admin$\file.txt C:..\file.txt \\?\C:\file.txt .././file.txt \\.\PhysicalDisk1\bob.txt \\;WebDavRedirector\bob.com\xyz C:\PROGRA~1\bob.txt .\A:B 

Resolvendo o problema via manipulação de caminho

Imagine o seguinte cenário: seu programa suporta um argumento de linha de comando, --output-path= , que permite aos usuários fornecer um caminho no qual seu programa deve criar arquivos de saída. Uma solução para criar arquivos no diretório especificado seria:

  1. Analise o caminho especificado pelo usuário com base no mini-idioma do sistema em que você está operando.
  2. Crie um novo caminho no mini-idioma que especifica o local correto para gravar o arquivo usando o nome do arquivo e as informações que você analisou na etapa 1.
  3. Abra o arquivo usando o caminho gerado na etapa 2.

Um exemplo de fazer isso:

No Linux, digamos que o usuário tenha especificado --output-path=/dir1/dir2

Analise este mini-idioma:

 /dir1/dir2 --> "/" root --> "dir1" directory under root --> "/" path seperator --> "dir2" directory under dir1 

Então, quando queremos gerar um arquivo no diretório especificado, construímos um novo caminho. Por exemplo, se quisermos bob.txt um arquivo chamado bob.txt , podemos construir o seguinte caminho:

 /dir1/dir2/bob.txt --> "/" root --> "dir1" directory under root --> "/" path separator --> "dir2" directory under dir1 --> "/" path seperator --> "bob.txt" file in directory dir2 

Podemos então usar esse novo caminho para criar o arquivo.

Em geral, é impossível implementar essa solução completamente. Mesmo se você pudesse escrever código que pudesse decodificar com sucesso todas as mini-linguagens de caminho existentes e representar corretamente as informações sobre cada sistema para que um novo caminho pudesse ser construído corretamente – no futuro seu programa pode ser construído ou executado em novos sistemas que tenham novas mini-linguagens de caminho que seu programa não pode manipular. Portanto, precisamos usar uma estratégia cuidadosa para gerenciar caminhos.

Estratégias de Manipulação de Caminho

1. Evite completamente a manipulação de caminhos

Não tente manipular os caminhos que são inseridos no seu programa. Você deve passar essas strings diretamente para as funções da API que podem manipulá-las corretamente. Isso significa que você precisa usar APIs específicas do sistema operacional diretamente, evitando as abstrações de E / S do arquivo C ++ (ou você precisa ter certeza absoluta de como essas abstrações são implementadas em cada sistema operacional). Certifique-se de projetar a interface do seu programa cuidadosamente para evitar uma situação em que você possa ser forçado a manipular caminhos. Tente implementar os algoritmos do seu programa para evitar a necessidade de manipular caminhos. Documente as funções api que seu programa usa em cada sistema operacional para o usuário – isso ocorre porque as próprias funções do sistema operacional se tornam obsoletas ao longo do tempo, portanto, no futuro, seu programa pode não ser compatível com todos os caminhos possíveis, mesmo se você tiver cuidado para evitar a manipulação de caminho.

2. Documente as funções que seu programa usa para manipular caminhos

Documente para o usuário exatamente como os caminhos serão manipulados. Em seguida, deixe claro que é responsabilidade do usuário especificar os caminhos que funcionarão corretamente com o comportamento do programa documentado.

3. Suporta apenas um conjunto restrito de caminhos

Restrinja as mini-linguagens de caminho que seu programa aceitará até que você tenha certeza de que pode manipular corretamente o subconjunto de caminhos que atendem a esse conjunto de restrições. Documente isso para o usuário. Erro se os caminhos forem inputs que não estão em conformidade.

4. Ignore os problemas

Faça alguma manipulação básica do caminho sem se preocupar muito. Aceite que seu programa exibirá comportamento indefinido para alguns caminhos que são inseridos. Você poderia documentar ao usuário que o programa pode ou não funcionar quando eles inserem caminhos para ele, e que os usuários são responsáveis ​​por garantir que o programa tenha manipulado os caminhos de input corretamente. No entanto, você também não pode documentar nada. Os usuários normalmente esperam que seu programa não manipule alguns caminhos corretamente (muitos não) e, portanto, funcionará bem mesmo sem documentação.

Pensamentos de encerramento

É importante decidir sobre uma estratégia eficaz para trabalhar com caminhos no início do ciclo de vida do seu programa. Se você tiver que alterar o modo como os caminhos são manipulados posteriormente, pode ser difícil evitar uma alteração no comportamento que possa interromper o programa para usuários existentes.

Isso precisa ser feito quando você abrir o arquivo, consulte o construtor std::ofstream ou o membro open() .

Não está muito claro o que você está perguntando; Se bem entendi, você recebe um nome de arquivo e deseja criar o arquivo em um diretório específico. Se for esse o caso, tudo o que é necessário é especificar o caminho completo para o construtor do ofstream . Você pode usar a concatenação de strings para construir esse caminho, mas eu recomendo fortemente o boost::filesystem::path . Tem todas as funções para fazer isso de forma portável e muito mais; caso contrário, você não será portátil (sem muito esforço), e até mesmo operações simples no nome do arquivo exigirão uma consideração considerável.

Eu estava preso nisso por um tempo e desde então descobri. O caminho é baseado no seu executável e varia um pouco. Para este exemplo, suponha que você faça um ls no seu diretório executável e veja:

 myprogram.out Saves 

Where Saves é uma pasta e myprogram.out é o programa que você está executando.

No seu código, se você estiver convertendo chars para um c_str() de uma maneira como esta:

 string file; getline(cin, file, '\n'); ifstream thefile; thefile.open( ("Saves/" + file + ".txt").c_str() ); 

e o usuário digitar savefile, seria

 "Saves/savefile.txt" 

que funcionará para chegar ao savefile.txt na sua pasta Saves. Observe que não há pré-barras e você apenas começa com o nome da pasta.

No entanto, se você estiver usando uma string literal como

 ifstream thefile; thefile.open("./Saves/savefile.txt"); 

seria assim para chegar à mesma pasta:

 "./Saves/savefile.txt" 

Observe que você começa com um ./ na frente do nome da pasta.

Tente isto:

 ofstream outfile; string createFile = ""; string path="/FULL_PATH"; createFile = path.as() + "/" + "SAMPLE_FILENAME" + ".txt"; outfile.open(createFile.c_str()); outfile.close(); //It works like a charm. 

Se você estiver usando o linux, tente execl (), com o comando mv.