Comment extraire une partie d'une chaine

Version imprimable

Hello tous

Je recois cette chaine de caractère

Code:

228,03,1771,2d71,17,49

et je n'ai besoin que de 1771 et de 17.

J'ai fais la fonction ci-dessous qui fonctionne.
J'informe la chaine, la position que je souhaite exploiter, le délimiteur que sépare les mots/caractères et la variable ou la partie souhaitée sera stoskée.

Je souhaiterais faire plus simple afin d'aléger mon code.

Es-ce qu'il y a une autre solution, comme une fonction existante?
Il mesemble qu'il y a une fonction qui commence par stro... . Je ne sais plus.
Auriez-vous un exemple à me donner?
Attention, la longeur de la partie à extraire peut changer de taille

Milles mercis

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
void WI968C::get_value(char * chaine, byte index, char * delimiter, char * get_val)
{
  // Get the value from a char delimited with comma
  // 123,rftzg,4568
  // get_value(1), will return rftzg
 
  // char chaine[]= {block0,block1,block2,block3}
 
  // Initiate the 
  byte ind = 0; // Position of the block of data into the chaine
  byte x = 0;   // index of val. Value to retunr.
  byte ic = 0;  // Index Chaine
  bool flag = false;  // True when it's part of block we need to extract
 
 
  // If we need the first block (block0), flag must be true
  if(index == 0)
  { 
    flag = true;
  }
 
  // In my comment, take in concideration that index is egal to 0. We need to print the first block : 'block0'
  do // Go trough chaine, one by one
  {
    //Serial.println(chaine[ic]);
    switch(chaine[ic]){
      case ' ':                 // When it read a comma, increment ind. Ind will no be egal to index and then val will not take new value. 
        if(chaine[ic]==delimiter[0])
        {
          ind++;                  // See default:
          ic++;
          continue;              // return to the begin of 'do' loop and check next position of chaine
        }
 
      case ',':
        if(chaine[ic]==delimiter[0])
        {
          ind++;
          ic++;
          continue;
        }
 
      case ':':
        if(chaine[ic]==delimiter[0])
        {
          ind++;
          ic++;
          continue;
        }
 
      default:
        if(ind == index)        // if ind is egal to index. Index is the block we decide to have printed
        {
          get_val[x] = chaine[ic];  // Store the desired value in val  
         // Serial.print(F("Def")); Serial.println(val[x]);
          x++;
        }
    }
 
    ic++;                       // Go to next position of chaine
    //Serial.print(F("co")); Serial.println(co);
 
  }while( ic <= strlen(chaine)); // As long as ic is < than the amount tof caracter in chaine, and then leave the do loop
  get_val[x]='\0';  // Close val with \0
 
  //Serial.print(F("sr:")); Serial.println(get_val);
  //return get_val;
}

Salut,

personnellement j'ai une fonction Split telle quelle

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void Split(const std::string& _str, const std::string& _sep, std::vector<std::string>* _parts)
		{
			if (!_parts)
				return;
			if (_sep.empty())
			{
				_parts->push_back(_str);
				return;
			}
			size_t start = 0;
			size_t pos = _str.find(_sep);
			while (pos != std::string::npos)
			{
				_parts->push_back(_str.substr(start, pos));
				start = pos + _sep.length();
				pos = _str.find(_sep, start);
			}
			_parts->push_back(_str.substr(start));
		}

23/09/2015, 02h25
koala01

Salut,

@Bousk : un ... pointeur sur un std::vector<std::string>:question: pourquoi pas une référence :question: A moins que ce ne soit qu'une erreur de retranscription :question: (hummm je n'y crois guère à cause du test effectué en tout début, test qui aurait été avantageusement remplacé par une assertion, soit dit en passant ;) )

Un peu trop de C++/CLI ces temps-ci :question:
23/09/2015, 08h54
Bousk

On a l'habitude de passer les paramètres out par pointeur, pour les différencier lors de l'appel.
Quant à l'assert au lieu du test, c'est pour empêcher tout crash si quelqu'un d'autre utilise mal la fonction, ce qui ferait louper une cert. Là on se retrouverait au pire avec un bug report "ça marche pas".
Mais j'ai fait effectivement un peu de C++/CLI dernièrement, c'est destabilisant au départ cette bestiole ^^
23/09/2015, 13h27
koala01

Citation:

Envoyé par Bousk

On a l'habitude de passer les paramètres out par pointeur, pour les différencier lors de l'appel.

Etrange, cette habitude, quand c'est le but des références (non constantes)

Citation:

Quant à l'assert au lieu du test, c'est pour empêcher tout crash si quelqu'un d'autre utilise mal la fonction, ce qui ferait louper une cert. Là on se retrouverait au pire avec un bug report "ça marche pas".

Et la programmation par contrat, inconnu au bataillon :question:

A priori, tu es face à une situation dans laquelle le contrat est violé par l'utilisateur de la fonction. La "mauvaise utilisation" de la fonction devrait avoir été repérée bien longtemps avant d'avoir atteint l'étape de certification ;)

D'autant plus que, encore une fois, l'utilisation d'une référence non constante aurait rendu le test totalement inutile (que ce soit le test que tu as écrit ou l'assertion que je propose), vu que l'on aurait eu la certitude que le paramètre existait au moment de l'appel.

Maintenant, il est vrai que je n'ai que très peu d'expérience dans le domaine de la certification.

Citation:

Mais j'ai fait effectivement un peu de C++/CLI dernièrement, c'est destabilisant au départ cette bestiole ^^

Ca, je ne te le fais pas dire ;)

Première étape

Citation:

Envoyé par pierrot10

Je souhaiterais faire plus simple afin d'aléger mon code.

Nouveau jour,

Je vous propose de vous amener à écrire une fonction correcte depuis votre façon actuelle de faire.

Déjà sans rien changer, sans le flag qui est pas utilisé et en enlevant les commentaires inutiles, est-ce que ça irait ça si j'ai pas ajouté d'erreur ?

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/// <summary>
/// Get the value from a string containing substrings delimited by a character.
/// </summary>
/// <remarks>
/// This is a function spec sample.
/// </remarks>
/// <param name="chaine">String like "block0,block1,block2,block3"</param>
/// <example>
/// <code>
/// get_value("123,rftzg,4568", 1, ',', *result)
/// </code>
/// Will return rftzg.
/// </example>
void WI968C::get_value(char * chaine, byte index, char * delimiter, char * get_val)
{
  byte ind = 0;       // Position of the block of data into the chaine
  byte x = 0;         // index of val. Value to retunr.
  byte ic = 0;        // Index Chaine
 
  do
  {
    //Serial.println(chaine[ic]);
    switch ( chaine[ic] )
    {
      case ' ':                 
      case ',':
      case ':':
        if ( chaine[ic] == delimiter[0] )
        {
          ind++;
          ic++;
        }
        break;
      default:
        if ( ind == index )
        {
          get_val[x] = chaine[ic];
          // Serial.print(F("Def")); Serial.println(val[x]);
          x++;
          ic++;
          //Serial.print(F("co")); Serial.println(co);
        }
        break;
    }
  }
  while ( ic <= strlen(chaine) );
  get_val[x] = '\0';
 
  //Serial.print(F("sr:")); Serial.println(get_val);
  //return get_val;
}

23/09/2015, 18h36
bacelar

Bon, je vais répondre au PO avec LA réponse bateau : regex:
http://www.cplusplus.com/reference/regex/
https://solarianprogrammer.com/2011/...egex-tutorial/