powłoka c ++ dla systemu Linux
#include <cstring>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <vector>
#include <filesystem>
#include <errno.h>
#include <bits/stdc++.h>
std::string USERDIR = getenv("HOME");
std::string ALIASFILE = USERDIR+"/shell/.alias";
std::vector<std::string> Split(std::string input, char delim);
void Execute(const char *command, char *arglist[]);
std::map<std::string, std::string> alias(std::string file);
bool BuiltInCom(const char *command, char *arglist[],int arglist_size);
char** conv(std::vector<std::string> source);
bool createAlias(std::string first, std::string sec);
std::string replaceAll(std::string data, std::map <std::string, std::string> dict);
int main() {
while (1) {
char path[100];
getcwd(path, 100);
char prompt[110] = "$[";
strcat(prompt, path);
strcat(prompt,"]: ");
std::cout << prompt;
// Takes input and splits it by space
std::string input;
getline(std::cin, input);
if(input == "") continue;
std::map<std::string, std::string> aliasDict = alias(ALIASFILE);
input = replaceAll(input, aliasDict);
std::vector<std::string> parsed_string = Split(input, ' ');
// Splits parsed_string into command and arglist
const char * com = parsed_string.front().c_str();
char ** arglist = conv(parsed_string);
// Checks if it is a built in command and if not, execute it
if(BuiltInCom(com, arglist, parsed_string.size()) == 0){
Execute(com, arglist);
}
delete[] arglist;
}
}
std::vector<std::string> Split(std::string input, char delim) {
std::vector<std::string> ret;
std::istringstream f(input);
std::string s;
while (getline(f, s, delim)) {
ret.push_back(s);
}
return ret;
}
void Execute(const char *command, char *arglist[]) {
pid_t pid;
//Creates a new proccess
if ((pid = fork()) < 0) {
std::cout << "Error: Cannot create new process" << std::endl;
exit(-1);
} else if (pid == 0) {
//Executes the command
if (execvp(command, arglist) < 0) {
std::cout << "Could not execute command" << std::endl;
exit(-1);
} else {
sleep(2);
}
}
//Waits for command to finish
if (waitpid(pid, NULL, 0) != pid) {
std::cout << "Error: waitpid()";
exit(-1);
}
}
bool BuiltInCom(const char *command, char ** arglist, int arglist_size){
if(strcmp(command, "quit") == 0){
delete[] arglist;
exit(0);
} else if(strcmp(command, "cd") == 0){
if(chdir(arglist[1]) < 0){
switch(errno){
case EACCES:
std::cout << "Search permission denied." << std::endl;
break;
case EFAULT:
std::cout << "Path points outside accesable adress space" << std::endl;
break;
case EIO:
std::cout << "IO error" << std::endl;
break;
case ELOOP:
std::cout << "Too many symbolic loops" << std::endl;
break;
case ENAMETOOLONG:
std::cout << "Path is too long" << std::endl;
break;
case ENOENT:
std::cout << "Path doesn't exist" << std::endl;
break;
case ENOTDIR:
std::cout << "Path isn't a dir" << std::endl;
break;
default:
std::cout << "Unknown error" << std::endl;
break;
}
return 1;
}
return 1;
} else if(strcmp(command, "alias") == 0){
if(arglist_size < 2){
std::cout << "[USAGE] Alias originalName:substituteName" << std::endl;
return 1;
}
std::string strArg(arglist[1]);
int numOfSpaces = std::count(strArg.begin(), strArg.end(), ':');
if(numOfSpaces){
std::vector<std::string> aliasPair = Split(strArg, ':');
createAlias(aliasPair.at(0), aliasPair.at(1));
return 1;
} else {
std::cout << "[USAGE] Alias originalName:substituteName" << std::endl;
return 1;
}
}
return 0;
}
char** conv(std::vector<std::string> source){
char ** dest = new char*[source.size() + 1];
for(int i = 0; i < source.size(); i++) dest[i] = (char *)source.at(i).c_str();
dest[source.size()] = NULL;
return dest;
}
std::map<std::string, std::string> alias(std::string file){
std::map<std::string, std::string> aliasPair;
std::string line;
std::ifstream aliasFile;
aliasFile.open(file);
if(aliasFile.is_open()){
while(getline(aliasFile, line)){
auto pair = Split(line, ':');
aliasPair.insert(std::make_pair(pair.at(0), pair.at(1)));
}
} else {
std::cout << "Error: Cannot open alias file\n";
}
return aliasPair;
}
std::string replaceAll(std::string data, std::map <std::string, std::string> dict){
for(std::pair <std::string, std::string> entry : dict){
size_t start_pos = data.find(entry.first);
while(start_pos != std::string::npos){
data.replace(start_pos, entry.first.length(),entry.second);
start_pos = data.find(entry.first, start_pos + entry.second.size());
}
}
return data;
}
bool createAlias(std::string first, std::string second){
std::ofstream aliasFile;
aliasFile.open(ALIASFILE, std::ios_base::app);
if(aliasFile.is_open()){
aliasFile << first << ":"<< second << std::endl;
return true;
} else return false;
}
Mam powłokę, którą zakodowałem w języku c ++ w dystrybucji Fedory Linux. Z zadowoleniem przyjąłbym ogólne ulepszenia dotyczące ulepszania kodu, ale szczególnie mile widziane byłyby komentarze dotyczące czytelności kodu
Odpowiedzi
Istnieje kilka ulepszeń, które możesz zrobić dla tego kodu, używając tylko klas i funkcji biblioteki standardowej języka C ++.
1. Nie używaj #include <bits/stdc++.h>
Nie ma gwarancji, że ten plik nagłówkowy istnieje i jest wewnętrznym plikiem specyficznym dla kompilatora. Użycie takich sprawi, że Twój kod będzie mniej przenośny.
Tylko #includenagłówki podane dla klas i funkcji, których chcesz użyć, ze standardowej biblioteki C ++.
Możesz przeczytać więcej o możliwych konsekwencjach i problemach tutaj: Dlaczego nie powinienem #include
Jak również nie #includenagłówków plików, w którym nic nie korzystają z nich (na przykład #include <filesystem>).
2. Nie używaj funkcji biblioteki c do manipulacji na napisach
Na przykład kod do budowania promptzmiennej można radykalnie uprościć, używając std::stringzamiast char*:
char path[100];
getcwd(path,100);
std::string prompt = "$[" + std::string(path) + "]:";
Możesz też po prostu pisać
if(command == "quit"){
przypuszczalnie używasz const std::string&jako typu dla commandparametru.
3. Nie musisz przydzielać tablic char*zmiennych, aby przekazywać je do execxy()funkcji
Właśnie zbudowałem std::vector<const char*>zamiast swojej conv()funkcji:
void Execute(const std::string& command, const std::vector<std::string>& args) {
std::vector<const char*> cargs;
pid_t pid;
for(auto sarg : args) {
cargs.append(sarg.data());
}
cargs.append(nullptr);
//Creates a new proccess
if ((pid = fork()) < 0) {
std::cout << "Error: Cannot create new process" << std::endl;
exit(-1);
} else if (pid == 0) {
//Executes the command
if (execvp(command.data(), cargs.data()) < 0) {
std::cout << "Could not execute command" << std::endl;
exit(-1);
} else {
sleep(2);
}
}
//Waits for command to finish
if (waitpid(pid, NULL, 0) != pid) {
std::cout << "Error: waitpid()";
exit(-1);
}
}
W takim przypadku, gdy używasz surowych wskaźników danych uzyskanych np. std::string::data(), Upewnij się, że okresy życia podstawowych zmiennych trwają przez cały okres ich używania np. W funkcjach biblioteki C.
Ogólna praktyczna zasada:
unikaj samodzielnego zarządzania pamięcią przy użyciu newi deletejawnie. Zamiast tego użyj standardowego kontenera C ++ lub przynajmniej inteligentnych wskaźników .
4. Nie potrzebujesz bezpośredniego porównania boolwartości
Zmiana
if(BuiltInCom(com, arglist, parsed_string.size()) == 0){
do
if(!BuiltInCom(com, arglist, parsed_string.size())){
Użyj również falsei truezamiast niejawnych konwersji z literałów int 0i 1.
5. Jeśli to możliwe, używaj parametrów consti przekazuj je przez odniesienie
Użyj, constjeśli nie musisz zmieniać parametru.
Użyj metody pass by reference ( &), jeśli chcesz uniknąć niepotrzebnych kopii tworzonych dla nietrywialnych typów.
Możesz zobaczyć, jak na przykładzie Execute()podanym powyżej.
To samo dotyczy na przykład
std::string replaceAll(std::string data, std::map <std::string, std::string> dict);
to powinno być
std::string& replaceAll(std::string& data, const std::map <std::string, std::string>& dict);
Formatowanie.
To jest jedna duża ściana tekstu. Musisz podzielić rzeczy na logiczne sekcje, aby ułatwić czytanie. Dodaj trochę pionowego odstępu między sekcjami, aby ułatwić czytanie.
Masz kilka #include. Miło jest je zamówić. Możesz wybrać dowolny sposób zamówienia, o ile jest to logiczne i ułatwia ludziom przeglądanie.
Robię najbardziej specyficzne dla najbardziej ogólnych.
#include "HeaderFileForThisSource.h"
#include "HeaderFileForOtherClassesInThisProject"
...
#include <C++ Librries>
...
#include <C Librries>
...
#include <Standard C++ Header Files>
..
#include <C standard Libraries>
...
Inni wymieniają je alfabetycznie.
Nie wiem, co jest najlepsze, ale przydałaby się logika do zamawiania.
To naprawdę trudne do odczytania. Nie widzę nazw funkcji w morzu tekstu.
std::vector<std::string> Split(std::string input, char delim);
void Execute(const char *command, char *arglist[]);
std::map<std::string, std::string> alias(std::string file);
bool BuiltInCom(const char *command, char *arglist[],int arglist_size);
char** conv(std::vector<std::string> source);
bool createAlias(std::string first, std::string sec);
std::string replaceAll(std::string data, std::map <std::string, std::string> dict);
Rozsądne użycie usingi sprzątanie sprawią, że będzie to naprawdę łatwe w użyciu.
using Store = std::vector<std::string>;
using Map = std::map<std::string, std::string>;
using CPPtr = char**;
Store Split(std::string input, char delim);
void Execute(const char *command, char *arglist[]);
Map alias(std::string file);
bool BuiltInCom(const char *command, char *arglist[],int arglist_size);
CPPtr conv(std::vector<std::string> source);
bool createAlias(std::string first, std::string sec);
std::string replaceAll(std::string data, std::map <std::string, std::string> dict);
Kod
Globalne „zmienne” to zły pomysł.
std::string USERDIR = getenv("HOME");
std::string ALIASFILE = USERDIR+"/shell/.alias";
Ustaw to w main(). Możesz następnie przekazać je jako parametry lub dodać je do obiektu.
Możesz mieć statyczny niezmienny stan w zakresie globalnym. Dotyczy to rzeczy takich jak stałe.
Ułatw czytanie.
while (1) {
Byłoby lepiej, ponieważ:
while(true) {
Nie używaj buforów o stałym rozmiarze, w których użytkownik może wprowadzić ciągi o dowolnej długości. C ++ radzi std::stringsobie w tego typu sytuacjach.
char path[100];
getcwd(path, 100);
// Rather
std::string path = std::filesystem::current_path().string();
Nie używaj magicznych liczb w swoim kodzie:
char prompt[110] = "$[";
Dlaczego 110? Umieść magiczne liczby w nazwanych stałych
// Near the top of the programe with all other constants.
// Then you can tune your program without having to search for the constants.
static std::size_t constepxr bufferSize = 110;
.....
char buffer[bufferSize];
Powinien być używany tutaj std :: string
strcat(prompt, path);
strcat(prompt,"]: ");
Stare funkcje napisów C nie są bezpieczne.