O system é utilizado para executar comandos do Prompt do Windows (ou Terminal em sistemas Unix), isso é útil para determinados programas. Veja um exemplo de uso (importe cstdlib):
#include <iostream>
#include <cstdlib>
using namespace std;
int main() {
system("dir");
return 0;
}
No caso acima, o dir (Windows), exibe as pastas e arquivos do diretório encontrado.
Outros comandos que podem ser muito usados são o cls (limpeza da tela) e pause (para pausar o programa).
Um exemplo que podemos usar também é o color, para mudar a cor do programa:
#include <iostream>
#include <cstdlib>
using namespace std;
int main() {
system("color FD");
return 0;
}
PS: Só é possível utilizar sempre a mesma cor para o programa todo.
Só que tem um porém, o comando cd não funciona no system (pelo fato dele não manter os dados após cada chamada), nesse caso é necessário utilizar o chdir (importe unistd.h) ou o SetCurrentDirectory (só em Windows, importe windows.h) para navegarmos por pastas no programa, dessa forma:
#include <iostream>
#include <cstdlib>
#include <unistd.h>
using namespace std;
int main() {
chdir("C:/Users");
system("dir");
return 0;
}
PS: Utilize sempre barras pra direita, as pra esquerda são interpretadas como sequências de escape. Caso use algum comando que tenha aspas, como os de navegação de pastas ou manipulação de registro, use sequências de escape \" e \\, aonde estiver " e \.
As variáveis do DOS/Terminal (como %username% em Windows ou $HOME em Unix) não são identificadas por esse método, nesse caso usamos o getenv, sem qualquer símbolo de indicação de variável. Veja um exemplo:
#include <iostream>
#include <cstdlib>
#include <unistd.h>
using namespace std;
int main() {
chdir(getenv("USERPROFILE"));
chdir("Desktop");
system("dir");
return 0;
}
PS: Em Windows é possível e até preferível usar no lugar do chdir, SetCurrentDirectory(), nesse caso importe windows.h.
O getenv funciona com esse parâmetros:
| Variável | Conteúdo Exibido |
|---|---|
| USERPROFILE | C:\Users\UsuarioAtual |
| PROGRAMDATA | C:\Programdata |
| ALLUSERSPROFILE | C:\Programdata |
| WINDIR | C:\Windows |
| SYSTEMROOT | C:\Windows |
| PROGRAMFILES | C:\Program Files |
| COMMONPROGRAMFILES | C:\Program Files\Common Files |
| USERNAME | "UsuarioAtual" |
| COMPUTERNAME | Nome do Computador |
| LOCALAPPDATA | C:\Users\Usuário Atual\AppData\Local |
| APPDATA | C:\Users\Usuário Atual\AppData\Roaming |
| ERRORLEVEL | Código de Erro do Último Comando (quando é diferente de 0). |
| CD | Pasta Atual |
| USERDOMAIN | Nome do Computador |
| SYSTEMDRIVE | C: |
| HOMEDRIVE | C: |
| SYSTEMDIRECTORY | C:\Windows\System32 |
| COMSPEC | C:\Windows\System32\cmd.exe |
| TEMP | C:\Users\Usuário Atual\AppData\Local\Temp |
| TMP | C:\Users\Usuário Atual\AppData\Local\Temp |
| HOMEPATH | \Users\Usuário Atual |
| PATH | Retorna o path do sistema |
| PATHEXT | Retorna as extensões de executáveis |
| OS | Retorna o nome do Sistema Operacional |
| PROCESSOR_IDENTIFIER | Retorna dados sobre o processador |
| PROCESSOR_ARCHITECTURE | Retorna a arquitetura do processador |
Para usar em Linux, o processo é o mesmo, só mudando a navegação entre pastas (seria coisas como /usr/local/bin) e os comandos do getenv, que são esses:
| Variável | Conteúdo Exibido |
|---|---|
| HOME | /home/UsuarioAtual |
| USER | "UsuarioAtual" |
| LOGNAME | "UsuarioAtual" |
| PWD | Diretório Atual |
| LANG | Idioma Atual |
| SHELL | /bin/bash (ou o Shell Atual) |
| TERM | Tipo de Terminal Usado |
| PATH | Diretórios a Pesquisar |
| E-mail Definido | |
| OSTYPE | Tipo de Sistema Usado |
Primeiramente, importe a biblioteca fstream. Basicamente, o ofstream é pra saída, o ifstream é de entrada e o fstream pode ser configurado para ambos.
Nessa parte, trabalharemos só com o ofstream. Que podemos fazer assim:
int main() {
ofstream arquivo; // Importe fstream
return 0;
}
Para criar o arquivo (se existir ele sobreescreverá o já existente), basta usar o método open(), assim:
int main() {
ofstream arquivo; // Importe fstream
arquivo.open("arquivo.txt");
return 0;
}
E para armazenar conteúdo nesse arquivo, basta fazer que nem o cout, o substituindo pela variável criada, assim:
int main() {
ofstream arquivo; // Importe fstream
arquivo.open("arquivo.txt");
arquivo << "Texto que será armazenado no arquivo!\n";
cout << "Arquivo Escrito com Sucesso!" << endl
return 0;
}
PS: Para liberar a memória, não esqueça de fechar o arquivo com o método close(), assim:
int main() {
ofstream arquivo; // Importe fstream
arquivo.open("arquivo.txt");
arquivo << "Texto que será armazenado no arquivo!\n";
arquivo.close();
cout << "Arquivo Escrito com Sucesso!" << endl
return 0;
}
PS: Ao executar novamente, ele vai substituir o texto escrito no arquivo, caso esteja outra coisa.
Para podermos adicionar conteúdo ao arquivo sem substituir, usamos um parâmetro adicional no open, o ios::app, assim:
arquivo.open("arquivo.txt", ios::app);
Podemos ter mais de uma inserção de conteúdo ao mesmo tempo, assim:
int main() {
ofstream arquivo; // Importe fstream
arquivo.open("arquivo.txt");
arquivo << "Linha 1!\n";
arquivo << "Linha 2!\n";
arquivo << "Linha 3!\n";
arquivo.close();
cout << "Arquivo Escrito com Sucesso!" << endl
return 0;
}
Para ler arquivos, usamos o ifstream, mas também precisaremos de uma string e um laço while para isso, como podemos ver no código, aproveitando o txt do programa anterior:
int main() {
ifstream entrada; // Importe fstream
string linha;
entrada.open("arquivo.txt");
if(entrada.is_open()) {
while(getline(entrada, linha)) {
cout << linha << endl;
}
entrada.close();
}
else {
cout << "Não foi possível abrir o arquivo!" << endl;
}
return 0;
}
Na classe Ofstream, só podemos usar para escrever no arquivo, assim como na classe Ifstream que só podemos usar para ler, mas podemos usar a classe Fstream para ambas as funções, com uma classe só.
Esse é o código que colocaremos no programa:
int main() {
fstream arquivo;
char opc;
string nome, linha;
arquivo.open("arquivo.txt", ios::out); // Saída do programa pro arquivo.
do {
cout << "Digite um nome: ";
cin >> nome;
arquivo << nome << "\n";
cout << "Deseja digitar mais nomes? [S/N] ";
cin >> opc;
system("cls"); // Importe cstdlib, use clear no Linux
}
while((char)toupper(opc) == 'S'); // Importe cctype
arquivo.close();
return 0;
}
Como visto, a única diferença no open, ao usar o fstream, é a indicação ios::out, que indica a saída do programa para o arquivo.
PS: Para não sobreescrever o arquivo, da mesma forma, podemos colocar o app no out, dessa forma:
arquivo.open("arquivo.txt", ios::out | ios::app);
Para ler o mesmo arquivo (entrada do arquivo para o programa)., use ios::in. Podemos fazer assim (coloque esse código logo abaixo do programa, antes do return):
arquivo.open("arquivo.txt", ios::in); // Entrada do arquivo pro programa.
if(arquivo.is_open()) {
cout << "Nomes digitados: " << endl << endl;
while(getline(arquivo, linha)) {
cout << linha << endl;
}
arquivo.close();
}
else {
cout << "Não foi Possível Abrir o Arquivo!" << endl;
}