Discussion :

[bm]

bonsoir ,

Je veux copier les char un à un dans un vector :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
char test[15]="0123456789";
vector <int> num(9);
 
  for(int i=1; i<num.size(); ++i)
  {
  int tt=test[i-1];
  num.at(i)=tt;
  cout << num.at(i) << "---" << test[i-1] << endl;
 
  }

48 -- 0
49 -- 1
50 -- 2
51 -- 3
52 -- 4
53 -- 5
54 -- 6
55 -- 7

C'est le passage char vers int , que je ne connais pas encore
en C++ .

[PilloBuenaGente]

Bonsoir !

Et la question ?

Pour passer de int à char suffit de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
int entier = 8;
char caractere = entier;

Les conversion entre type primitifs ne sont pas plus compliqués.

Si le problème est le décalage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <string>
#include <vector>
int main()
{
    std::string test("0123456789");//string est le conteneur de char par excellence
    std::vector<int> num(10);//zéro à dix
 
    for(int i = 0; i < num.size(); ++i)//un tableau commence à zéro
    {
        num[i] = test[i];//l'operator[] marche aussi ici
        std::cout << num.at(i) << "---" << test[i] << std::endl;
    }
    return 0;
}

[foetus]

C'est normal que cela ne fonctionne pas : tu prends un caractère donc un code ASCII et non pas un chiffre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include<iostream>
#include <iomanip>
#include<vector>
 
using namespace std;
 
 
int main(int argc, char* argv[])
{
    char test[]="0123456789";
    vector<int> num;
 
    unsigned char c = 0, len = 10 /*hardcoded*/;
 
    num.reserve(len);
 
    for(; c < len; ++c) {
        num.push_back(test[c] - '0' + 1);
    }
 
    for(c = 0; c < len; ++c) {
        cout << setw(2) << num[c] << "---" << test[c] << endl;
    }
 
//  Extra: :-)
    cout << endl << "[";
 
    for(vector<int>::iterator it = num.begin(); it < num.end(); ++it) {
        cout << ((it != num.begin())? ", ": "") << *it;
    }
    cout << "]" << endl;
 
    return 0;
}

[Ehonn]

Pour les copier tels quels, on peut utiliser le constructeur de vecteur qui prend des itérateurs, voici un exemple C++98 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++11 -pedantic -fopenmp main.cpp -o main && ./main
// g++ -Wall -Wextra -Wconversion -Wsign-conversion -std=c++98 -pedantic -fopenmp main.cpp -o main && ./main
 
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
 
 
int main()
{
	// Avec std::string
	{
		std::string s("Test avec std::string");
		std::vector<int> v(s.begin(), s.end());
		for (std::size_t i = 0; i < v.size(); ++i) { std::cout << v[i] << " "; } std::cout << std::endl;
	}
 
	// Avec char const * const
	{
		char const * const s = "Test avec char const * const"; // Utiliser std::string !
		std::vector<int> v(s, s + strlen(s));
		for (std::size_t i = 0; i < v.size(); ++i) { std::cout << v[i] << " "; } std::cout << std::endl;
	}
 
	return 0;
}

Si on veut les copier en les modifiant, on peut utiliser std::transform.

[bm]

merci des conseils :

char [] est trop restrictif

[therwald]

merci des conseils :

char [] est trop restrictif

trop restrictif pour quoi?

qu'est-ce que tu essaie de faire, exactement?

[foetus]

trop restrictif pour quoi?

Parce qu'il faut connaître la taille de ton tableau : avec un strlen?
Est-ce que tu es sûr à 100% que le compilateur va mettre la sentinelle '\0' à la fin.
Ou bien la mettre à la main. Mais 1) il ne faut pas l'oublier quelque part 2) l'éviter lors des algos.

Parce que sinon, il faut passer par des vector qui sont des tableaux à taille variable

[therwald]

OK, je l'aurais pas exprimé comme ça, mais sur le fond je suis d'accord: les char[] sont nettement plus galère à manier, et source d'erreurs. Mais ce que je me demande, c'est pourquoi tu tiens asolumet à employer des vector<int> pour stocker tes char? Ce sont biens de caractères que tu veux stocker et manier?

[foetus]

OK, je l'aurais pas exprimé comme ça, mais sur le fond je suis d'accord: les char[] sont nettement plus galère à manier, et source d'erreurs. Mais ce que je me demande, c'est pourquoi tu tiens asolumet à employer des vector<int> pour stocker tes char? Ce sont biens de caractères que tu veux stocker et manier?

Tu sais les char sont aussi des entiers ... mais soit [-127, 127] soit [0, 255].

Cela dépend de la compréhension ... et surtout ne pas oublier d'ajouter/ de retirer le caractère '0' pour passer d'une signification à l'autre.

[koala01]

Salut,

De manière générale, les char sont des entiers, soit... Mais leur valeur "numérique" correspond en réalité à l'index du "glyphe" qui sera affiché dans ce que l'on appelle une table de caractères.

La table de caractères utilisées "classiquement" est ce que l'on appelle la table ASCII (American Standard Code for Information Interchange).

Dans cette table de caractères (et dans les autres aussi, d'ailleurs, car nous sommes là au niveau de quelque chose qui est globalement respecté par les autres tables de caractères), le "glyphe" correspondant au premier chiffre que l'on rencontre est le glyphe représentant le "0" et il a pour index la valeur 48.

Les autres chiffres suivent dans l'ordre (1,2,3,4,5,6,7,8 et 9), ce qui fait que l'on y accède donc respectivement avec les indices 49,50,51,52,43,54,55,56 et 57.

Lorsque tu essayes de placer un char dans n'importe quelle collection contenant des int, cela revient tout simplement à dire "je veux la valeur numérique de l'indice coorespondant" car les int sont des valeurs exclusivement numériques.

Il n'y a donc absolument rien de surprenant au fait que, si tu demande l'affichage des différents éléments que tu trouves dans la collection en question, tu obtiennes l'affichage des valeurs numériques correspondant aux indices dans la table ASCII.

Evidemment, je ne reviendrai pas sur le fait que la gestion de chaînes de caractères en C++ se fait exclusivement à l'aide de std::string, ne serait-ce que parce que, cette classe est prévue pour et qu'elle est beaucoup plus sécurisante que tout ce qu'il y a moyen de (mal) faire avec les fonctionnalités propres au C

[therwald]

Tu sais les char sont aussi des entiers ... mais soit [-127, 127] soit [0, 255].

Cela dépend de la compréhension ... et surtout ne pas oublier d'ajouter/ de retirer le caractère '0' pour passer d'une signification à l'autre.

Ouais. D'ailleurs je propose aussi de stocker les caractères sous forme de l'index de leur première occurrence dans la bible personnelle de Calvin. Après il suffit d'encoder un fac-similé de l'original de cette bible dans tout logiciel. Après tout, y'a qu'à faire la transco...
Ou alors tu utilises les outils largement au point que C++ propose, tels que std::string comme le propose koala01, et tu verras que :
1) le code sera plus conçis
2) le code sera plus fiable
3) tu consommeras environ 100 fois moins d'aspirine.



Bon, galéjades mises à part, on se facilité quand même grandement la vie en profitant des outils mis en place. Et en plus, comme la sémantique d'une std::string indique clairement à tout le monde qu'on parle de caractères, le risque d'erreur est fortement diminué.
Par contre, iil y a eu une confusion: ma question visait à pousser le PO, bm, à préciser son besoin, qui ne me paraît pas clair, afin qu'on puisse comprendre pour quoi il veut absolument stocker ses char dans un std::vector<int> au lieu d'une std::string ou à la rigueur un std::vector<char>...et proposer une solution appropriée au problème.

[PilloBuenaGente]

Il voulait peut être tout simplement faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cout << (char)num.at(i) << "---" << test[i-1] << endl;

[foetus]

Ou alors tu utilises les outils largement au point que C++ propose, tels que std::string comme le propose koala01, et tu verras que :
1) le code sera plus conçis
2) le code sera plus fiable
3) tu consommeras environ 100 fois moins d'aspirine.

Le std::string c'est de la m*rd* pour la gestion de l'Unicode UTF-8/ UTF-16

Mais bon ce n'est pas de sa faute non plus


Et enfin l'autre truc, c'est que un [unsigned] char c'est 1 et 1 seul octet. Et un [unsigned] short c'est au moins 2 octets

Tout cela pour dire que des fois on doit coder des structures/ des classes pas trop grosses en mémoire et que mettre des int (qui varient entre 4 et 8 octets) lorsque tu connais la limite max à 100% c'est overkill. Par exemple, une requête URL c'est maximum 1024 caractères (du moins tu peux la fixer sereinement)

Et cela parce qu'il y a jamais eu de type byte. Parce que justement la différence entre un vrai type byte et un [unsigned] char c'est la valeur 0/ le caractère '\0'

Il voulait peut être tout simplement faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cout << (char)num.at(i) << "---" << test[i-1] << endl;

Non le problème que semble avoir bm c'est que pour le chiffre 0, 48 s'affiche . Et ainsi de suite.

[PilloBuenaGente]

Non le problème que semble avoir bm c'est que pour le chiffre 0, 48 s'affiche . Et ainsi de suite.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
#include <iostream>
//------------------------------------------------------------------------------
int main()
{
    int integer = 48;
    std::cout << (char)integer;
    return 0;
}

Affiche bien 0

[therwald]

@foetus: en fait, ce serait bien que tu le laisses parler.
Tu amène dans la conversation de nombreux problèmes dont on ne sait pas du tout s'ils ont un rapport avec le projet de bm. Or pour faire de la bonne info, il faut répondre au problème posé, non à l'ensemble des problèmes du monde plus ceux d'une ou deux planètes extrasolaires...pour de nombreux usages std::string suffit. Dans certains cas std::wstring pourra servir.
@bm:
d'où viennent ces caractères que tu transfères dans un vector?
comment comptes-tu les exploiter?

[bm]

ok , je n'ai pas encore lu tous les commentaires ..

http://submoon.freeshell.org/fr/sphinx/euler.html

C'est pour le problème N°8 . Les tuples avec python font que j'ai des lacunes
avec les déclarations des biblio du C++ .

C'est pour du loisir et je ne percute pas vite avec les meilleures solutions
qu'il faut développer ..

[therwald]

OK, donc là on est dans une autre problématique, et effectivement un std::vector<int> est approprié (short pourrait convenir vu que le produit est <=10⁵ et qu'un short peut stocker au moins sur [-32767;32768].
Par contre, pour résoudre le problème tu dois décoder tes char, et non les convertir.
Le décodage d'un char se fait classiquement par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
char carac=<source du char à traiter>;
int val=carac-'0';

(sachant que soit tu pars du principe que tu n'auras que les char {'0','1','2','3','4','5','6','7','8','9'} dans ta chaine de caractères initiale, sois tu fais un test de validité:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if(carac<'0' || carac > '9'){
   throw std::out_of_range("pas un chiffre!");
}
int val=carac-'0';

[bm]

ok , c'est pas mal de déclarations pour sortir tous les caractères un à un d'un tuple .
Mais ce tuple , il faut le créer de toute pièce avec du C++ ..

@therwald :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
int main(){
 
    std::string test("0123456789");//string est le conteneur de char par excellence
    std::vector<short> num(10);//zéro à dix
 
    for(int i = 0; i < num.size(); ++i)//un tableau commence à zéro
    {
 
        char carac=getMyChar(test[i]);
        int val=carac-'0';
        num.at[i] = val;//l'operator[] marche aussi ici
        std::cout << num(i) << "---" << test[i] << std::endl;
    }
    return 0;
}

Comment déclarer cette fonction getMyChar ?

[therwald]

Pas besoin de la déclarer, c'était un placeholder (ce que je vais d'ailleurs rendre plus clair dans mon post précédent).

Donc au final:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
   for(int i = 0; i < num.size(); ++i)//un tableau commence à zéro
    {
 
        char carac=test[i];
        int val=carac-'0';
        num.at[i] = val;//l'operator[] marche aussi ici
        std::cout << num(i) << "---" << test[i] << std::endl;
    }

[bm]

||=== Générer: Debug in Tuple (compiler: GNU GCC Compiler) ===|
16|error: invalid types ‘<unresolved overloaded function type>[int]’ for array subscript|
17|error: no match for call to ‘(std::vector<int>) (int&)’|
||=== Build échoué: 2 error(s), 1 warning(s) (0 minute(s), 0 second(s)) ===|

16 / num.at[i] = val;//l'operator[] marche aussi ici
17 / std::cout << num(i) << "---" << test[i] << std::endl;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
int main(){
 
    std::string test("0123456789");//string est le conteneur de char par excellence
    std::vector<int> num(10);//zéro à dix
 
    for(int i = 0; i < num.size(); ++i)//un tableau commence à zéro
    {
        char carac=test[i];
        int val=carac-'0';
        num.at[i] = val;//l'operator[] marche aussi ici
        std::cout << num(i) << "---" << test[i] << std::endl;
    }
    return 0;
}