409 lines
14 KiB
C++
Executable file
409 lines
14 KiB
C++
Executable file
// This file is part of the Herezh++ application.
|
|
//
|
|
// The finite element software Herezh++ is dedicated to the field
|
|
// of mechanics for large transformations of solid structures.
|
|
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
|
|
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
|
|
//
|
|
// Herezh++ is distributed under GPL 3 license ou ultérieure.
|
|
//
|
|
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
|
|
// AUTHOR : Gérard Rio
|
|
// E-MAIL : gerardrio56@free.fr
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License,
|
|
// or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
//
|
|
// For more information, please consult: <https://herezh.irdl.fr/>.
|
|
|
|
#include "CharUtil.h"
|
|
#include <sstream> // for istringstream
|
|
using namespace std;
|
|
#include <limits>
|
|
|
|
// transformation d'un string ou d'une chaine de character en entier
|
|
int ChangeEntier(string st)
|
|
{ using namespace std;
|
|
char * chh = (char*)st.c_str();
|
|
#ifndef ENLINUX_STREAM
|
|
istringstream flux (chh);
|
|
#else
|
|
istrstream flux (chh);
|
|
#endif
|
|
|
|
int i;
|
|
flux >> i;
|
|
return i;
|
|
};
|
|
int ChangeEntier(char * st)
|
|
{using namespace std;
|
|
#ifndef ENLINUX_STREAM
|
|
istringstream flux (st);
|
|
#else
|
|
istrstream flux (st);
|
|
#endif
|
|
int i;
|
|
flux >> i;
|
|
return i;
|
|
};
|
|
|
|
// test d'un nombre numérique: ref: http://rosettacode.org/wiki/Determine_if_a_string_is_numeric
|
|
bool isNumeric( const char* pszInput, int nNumberBase )
|
|
{
|
|
istringstream iss( pszInput );
|
|
|
|
if ( nNumberBase == 10 )
|
|
{
|
|
double dTestSink;
|
|
iss >> dTestSink;
|
|
}
|
|
else if ( nNumberBase == 8 || nNumberBase == 16 )
|
|
{
|
|
int nTestSink;
|
|
iss >> ( ( nNumberBase == 8 ) ? oct : hex ) >> nTestSink;
|
|
}
|
|
else
|
|
return false;
|
|
|
|
// was any input successfully consumed/converted?
|
|
if ( ! iss )
|
|
return false;
|
|
|
|
// was all the input successfully consumed/converted?
|
|
return ( iss.rdbuf()->in_avail() == 0 );
|
|
};
|
|
|
|
// transformation d'un string ou d'une chaine de character en relle
|
|
double ChangeReel(string st)
|
|
{ using namespace std;
|
|
|
|
#ifndef ENLINUX_STREAM
|
|
istringstream flux ((char*) st.c_str());
|
|
#else
|
|
istrstream flux ((char*) st.c_str());
|
|
#endif
|
|
double i;
|
|
flux >> i;
|
|
return i;
|
|
};
|
|
|
|
double ChangeReel(char * st)
|
|
{ using namespace std;
|
|
#ifndef ENLINUX_STREAM
|
|
istringstream flux (st);
|
|
#else
|
|
istrstream flux (st);
|
|
#endif
|
|
double i;
|
|
flux >> i;
|
|
return i;
|
|
};
|
|
// recherche "nom" dans le tableau "tabMot", si nom existe ramene true, sinon false
|
|
bool ExisteString (Tableau<string>& tabMot,string nom)
|
|
{ for (int i=1;i<= tabMot.Taille();i++)
|
|
if (tabMot(i) == nom)
|
|
return true;
|
|
return false;
|
|
};
|
|
// transformation d'un entier en chaine de caractere correspondant
|
|
string ChangeEntierSTring(int a)
|
|
{ int b = a ;
|
|
string sor = "";
|
|
do
|
|
{ // on recherche la derniere decimale
|
|
int reste = b % 10 ;
|
|
// on ajoute a la chaine
|
|
sor = ChangeEntierChar(reste) + sor;
|
|
// on calcul le chiffre des dizaines
|
|
b = b/10;
|
|
} while (b != 0) ;
|
|
return sor;
|
|
} ;
|
|
// transformation d'un réel en chaine de caractère correspondant
|
|
string ChangeReelSTring(double a)
|
|
{using namespace std;
|
|
char tab[50]; // 50 caractères pour écrire le réel !!
|
|
char* st = tab;
|
|
#ifndef ENLINUX_STREAM
|
|
ostringstream flux (st,50);
|
|
#else
|
|
ostrstream flux (st,50);
|
|
#endif
|
|
flux << a << ends;
|
|
return st;
|
|
};
|
|
|
|
// transformation d'un entier de 0 a 10 en 1 caractere correspondant
|
|
// il existe une fonction _itoa qui fait le meme travail qui se trouve dans extras.h
|
|
char* ChangeEntierChar(int a)
|
|
{ char* result= " ";
|
|
switch (a)
|
|
{ case 0 :
|
|
result="0";break;
|
|
case 1 :
|
|
result="1";break;
|
|
case 2 :
|
|
result="2";break;
|
|
case 3 :
|
|
result="3";break;
|
|
case 4 :
|
|
result="4";break;
|
|
case 5 :
|
|
result="5";break;
|
|
case 6 :
|
|
result="6";break;
|
|
case 7 :
|
|
result="7";break;
|
|
case 8 :
|
|
result="8";break;
|
|
case 9 :
|
|
result="9";break;
|
|
default :
|
|
cout << "\nErreur : l'entier n'est pas compris entre 0 et 9 !\n";
|
|
cout << "ChangeEntierChar(int a) \n";
|
|
Sortie(1);
|
|
};
|
|
return result;
|
|
};
|
|
|
|
// transformation d'un string en minuscules
|
|
string Minuscules(const string& st)
|
|
{ using namespace std;
|
|
unsigned long int lon= st.length ();
|
|
string reponse;
|
|
for (unsigned long int i=0;i<lon;i++)
|
|
reponse += (char) tolower(st[i]);
|
|
return reponse;
|
|
};
|
|
// -------- utilitaire pour lire une chaine de caractères:
|
|
// si retour chariot, retourne la valeur par défaut passée en paramètre
|
|
// sinon retourne le string lue au clavier
|
|
// gestion d'erreur si lecture non correcte
|
|
// si avec_ecriture = true: on écrit "--> valeur par defaut : n " val_defaut
|
|
string lect_return_defaut(bool avec_ecriture,string val_defaut)
|
|
{ string rep;
|
|
bool entree_non_valide = true;
|
|
while (entree_non_valide)
|
|
{ // on s'intéresse d'abord au retour chariot
|
|
int c = std::cin.peek(); // peek character (sans changer le flux !!)
|
|
if (( c == EOF )||(c=='\n'))
|
|
{rep = val_defaut;
|
|
if (avec_ecriture)
|
|
cout << "--> valeur par defaut : "<< val_defaut << flush ;
|
|
c = getchar(); // on lit quand même le caractère
|
|
entree_non_valide = false;
|
|
}
|
|
else // sinon on peut lire
|
|
{std::getline (std::cin,rep);};
|
|
// gestion d'erreur éventuelle
|
|
if ( std::cin.fail() || std::cin.eof())
|
|
{std::cout << "\n Saisie incorrecte, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
}
|
|
else // sinon c'est ok
|
|
{entree_non_valide = false;};
|
|
};
|
|
// retour de l'info
|
|
return rep;
|
|
};
|
|
|
|
// lecture d'une chaine de caractère via getline: pas de validation
|
|
// tant qu'il n'y a rien de lue
|
|
// gestion d'erreur si lecture non correcte
|
|
string lect_chaine()
|
|
{ string rep;
|
|
bool entree_non_valide = true;
|
|
while (entree_non_valide)
|
|
{ // on s'intéresse d'abord au retour chariot
|
|
int c = std::cin.peek(); // peek character (sans changer le flux !!)
|
|
if (( c == EOF )||(c=='\n'))
|
|
{std::cout << "\n Saisie incorrecte, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
entree_non_valide = false;
|
|
}
|
|
else // sinon on peut lire
|
|
{std::getline (std::cin,rep);};
|
|
// gestion d'erreur éventuelle
|
|
if ( std::cin.fail() || std::cin.eof())
|
|
{std::cout << "\n Saisie incorrecte, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
}
|
|
else // sinon c'est ok
|
|
{entree_non_valide = false;};
|
|
};
|
|
// retour de l'info
|
|
return rep;
|
|
};
|
|
|
|
|
|
// lecture d'un scalaire réel avec getline
|
|
// gestion d'erreur si lecture non correcte
|
|
double lect_double()
|
|
{ string rep;
|
|
bool entree_non_valide = true;
|
|
while (entree_non_valide)
|
|
{ // on s'intéresse d'abord au retour chariot
|
|
int c = std::cin.peek(); // peek character (sans changer le flux !!)
|
|
if (( c == EOF )||(c=='\n'))
|
|
{std::cout << "\n Saisie incorrecte, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
entree_non_valide = false;
|
|
}
|
|
else // sinon on peut lire
|
|
{std::getline (std::cin,rep);};
|
|
// gestion d'erreur éventuelle
|
|
if ( std::cin.fail() || std::cin.eof())
|
|
{std::cout << "\n Saisie incorrecte, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
}
|
|
else // sinon c'est ok
|
|
{entree_non_valide = false;};
|
|
};
|
|
// on traduit en réel
|
|
double result = ChangeReel(rep);
|
|
// retour de l'info
|
|
return result;
|
|
};
|
|
|
|
|
|
//
|
|
//rep = lect_return_defaut(false,"f");
|
|
//rep = lect_return_defaut(false,"o");
|
|
//rep = lect_return_defaut(true,"o");
|
|
//= lect_chaine();
|
|
//rep = lect_chaine();
|
|
//(int) lect_double();
|
|
//#include "CharUtil.h"
|
|
|
|
|
|
// cas d'une valeur o/n , sinon pas acceptable
|
|
// si avec_ecriture = true: on écrit "--> valeur lue : " valeur lue
|
|
string lect_o_n(bool avec_ecriture)
|
|
{ string rep;
|
|
bool entree_non_valide = true;
|
|
while (entree_non_valide)
|
|
{ // on s'intéresse d'abord au retour chariot
|
|
int c = std::cin.peek(); // peek character (sans changer le flux !!)
|
|
if (( c == EOF )||(c=='\n'))
|
|
{// ce n'est pas acceptable
|
|
std::cout << "\n Saisie incorrecte1, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
entree_non_valide = false;
|
|
}
|
|
else // sinon on peut lire
|
|
{std::getline (std::cin,rep);};
|
|
// gestion d'erreur éventuelle
|
|
if ( std::cin.fail() || std::cin.eof())
|
|
{std::cout << "\n Saisie incorrecte2, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
}
|
|
else // sinon c'est ok
|
|
{ rep = Minuscules(rep);
|
|
if (!((rep == "o") || (rep == "n")))
|
|
{std::cout << "\n Saisie incorrecte3, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
}
|
|
else // sinon ouf, c'est ok
|
|
{entree_non_valide = false;
|
|
if (avec_ecriture)
|
|
cout << "--> valeur lue : "<< rep << flush ;
|
|
};
|
|
};
|
|
};
|
|
// retour de l'info
|
|
return rep;
|
|
};
|
|
|
|
// cas d'une valeur 1/0 , sinon pas acceptable
|
|
// si avec_ecriture = true: on écrit "--> valeur lue : " valeur lue
|
|
string lect_1_0(bool avec_ecriture)
|
|
{ string rep;
|
|
bool entree_non_valide = true;
|
|
while (entree_non_valide)
|
|
{ // on s'intéresse d'abord au retour chariot
|
|
int c = std::cin.peek(); // peek character (sans changer le flux !!)
|
|
if (( c == EOF )||(c=='\n'))
|
|
{// ce n'est pas acceptable
|
|
std::cout << "\n Saisie incorrecte1, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
}
|
|
else // sinon on peut lire
|
|
{std::getline (std::cin,rep);};
|
|
// gestion d'erreur éventuelle
|
|
if ( std::cin.fail() || std::cin.eof())
|
|
{std::cout << "\n Saisie incorrecte2, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
|
|
}
|
|
else // sinon c'est ok
|
|
{ rep = Minuscules(rep);
|
|
if (!((rep == "1") || (rep == "0")))
|
|
{std::cout << "\n Saisie incorrecte3, recommencez : ";
|
|
std::cin.clear(); // effacer les bits d'erreurs
|
|
}
|
|
else // sinon ouf, c'est ok
|
|
{entree_non_valide = false;
|
|
if (avec_ecriture)
|
|
cout << "--> valeur lue : "<< rep << flush ;
|
|
};
|
|
};
|
|
};
|
|
// retour de l'info
|
|
return rep;
|
|
};
|
|
|
|
// lecture du prochain caractère non espace et non vide dans le flot sans modifier le flot
|
|
// en remplacement de la méthode peek qui ne marche pas avec code warrior
|
|
// si pb ou aucun caractère, retour du caractère "espacement"
|
|
char Picococar(ifstream& entr)
|
|
{ char car; // = flot.peek();
|
|
entr >> car;
|
|
// si pb cela signifie qu'en fait la ligne est terminée donc on s'arrête
|
|
if (entr.rdstate() != 0) {return ' ';}
|
|
// sinon on lit jusqu'à un caratère non nul
|
|
while ( (car==' ') && (entr.rdstate() == 0 ))
|
|
// cas où le prochain caractère est un espace
|
|
{ entr >> car;
|
|
}
|
|
// si c'est une sortie car pb on retourne car c'est la fin de ligne
|
|
if (entr.rdstate() != 0) return ' ';
|
|
// sinon on remet le caractère dans le flot
|
|
entr.putback(car);
|
|
return car;
|
|
};
|
|
char Picococar(istrstream& entr)
|
|
{ char car; // = flot.peek();
|
|
entr >> car;
|
|
// si pb cela signifie qu'en fait la ligne est terminée donc on s'arrête
|
|
if (entr.rdstate() != 0) {return ' ';}
|
|
// sinon on lit jusqu'à un caratère non nul
|
|
while ( (car==' ') && (entr.rdstate() == 0 ))
|
|
// cas où le prochain caractère est un espace
|
|
{ entr >> car;
|
|
}
|
|
// si c'est une sortie car pb on retourne car c'est la fin de ligne
|
|
if (entr.rdstate() != 0) return ' ';
|
|
// sinon on remet le caractère dans le flot
|
|
entr.putback(car);
|
|
return car;
|
|
};
|
|
|