Expression régulière dans regex.h

myreg.cpp



#include <sys/types.h>
#include <regex.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#include <string>
#include <map>

typedef std::string Str;
typedef std::map< int, Str > Mis;
typedef std::map< int, Mis > Mimis;
int myreg( Str input_string, Str pattern, Mimis &ret, size_t back_ref_size = 42 );

int myreg( Str input_string, Str pattern, Mimis &result, size_t back_ref_size ) {
	
	int ret = 0;
	regex_t rg;
	
	//cflag est REG pour le moment_Avec EXTENDED. Consultez la page de manuel regcomp pour savoir comment le comportement change.
	ret = regcomp( &rg, pattern.c_str(), REG_EXTENDED );
	
	if( ret ) {
		
		char buf[1024] = "";
		regerror( ret, &rg, buf, 1024 );
		
		fprintf( stderr, "regcomp failed. %s\n", buf );
		
		regfree( &rg );
		return( 1 );
		
	}
	
	int match_count = 0;
	
	while( 1 ) {
		
		regmatch_t *matching = new regmatch_t[back_ref_size];
		
		//eflag vaut 0 pour le moment. Consultez la page de manuel regexec pour savoir comment le comportement change.
		ret = regexec( &rg, input_string.c_str(), back_ref_size, matching, 0 );
		
		if( ret ) {
			
			//Ce n'est pas une erreur, il n'y a simplement aucune correspondance
			delete [] matching;
			break;
			
		}
		
		int first_end_index = -1; //Extrayez la première position de fuite.
		int back_ref_count = 0;
		
		for( size_t i = 0; i < back_ref_size; ++i, ++back_ref_count ) {
			
			int start_index = matching[i].rm_so;
			int end_index = matching[i].rm_eo;
			
			if( start_index == -1 || end_index == -1 ) {
				
				break;
				
			}
			
			if( i == 0 ) {
				
				first_end_index = end_index;
				
				//Mesures de correspondance vides.
				if( start_index == end_index ) {
					
					++first_end_index;
					
				}
				
			}
			
			int len = end_index - start_index;
			
			if( len ) {
				
				result[match_count][back_ref_count] = input_string.substr( start_index, len );
				
			} else {
				
				result[match_count][back_ref_count] = "";
				
			}
			
		}
		
		if( first_end_index == -1 ) {
			
			delete [] matching;
			break;
			
		}
		
		input_string = input_string.substr( first_end_index );
		
		if( input_string.empty() ) {
			
			delete [] matching;
			break;
			
		}
		
		++match_count;
		
	}
	
	regfree( &rg );
	return( 0 );
	
}

int main( int argc, char **argv ) {
	
	if( argc != 3 ) {
		
		printf( "./myreg input_string pattern\n\n" );
		return( 1 );
		
	}
	
	printf( "input_string:\n%s\n", argv[1] );
	printf( "\n" );
	printf( "pattern:\n%s\n", argv[2] );
	printf( "\n" );
	
	Mimis result;
	
	if( myreg( argv[1], argv[2], result ) ) {
		
		return( 1 );
		
	}
	
	printf( "result:\n" );
	
	for( Mimis::iterator it = result.begin(), eit = result.end(); it != eit; ++it ) {
		
		for( Mis::iterator itt = it->second.begin(), eitt = it->second.end(); itt != eitt; ++itt ) {
			
			printf( "%d %d %s\n", it->first, itt->first, itt->second.c_str() );
			
		}
		
	}
	
	return( 0 );
	
}


Il semble que les expressions régulières en C et C ++ ne peuvent pas être utilisées rapidement.

C'est pourquoi j'ai décidé d'utiliser la fonction regex POSIX.

Et voici le code que j'ai créé.

Vous pouvez également récupérer l'intégralité de la correspondance + référence arrière. (Il est difficile d'écrire tout le traitement des références en amont par vous-même, n'est-ce pas?)

Résultat d'exécution ci-dessous


[todanano@localhost samba]$ ./myreg 'abc123def' '(abc).*(def)'
input_string:
abc123def

pattern:
(abc).*(def)

result:
0 0 abc123def
0 1 abc
0 2 def
[todanano@localhost samba]$
[todanano@localhost samba]$ ./myreg '192.168.0.1-192.168.0.254' '([[:digit:]]{1,3})\.([[:digit:]]{1,3})\.([[:digit:]]{1,3})\.([[:digit:]]{1,3})'
input_string:
192.168.0.1-192.168.0.254

pattern:
([[:digit:]]{1,3})\.([[:digit:]]{1,3})\.([[:digit:]]{1,3})\.([[:digit:]]{1,3})

result:
0 0 192.168.0.1
0 1 192
0 2 168
0 3 0
0 4 1
1 0 192.168.0.254
1 1 192
1 2 168
1 3 0
1 4 254
[todanano@localhost samba]$
[todanano@localhost samba]$

Recommended Posts

Expression régulière dans regex.h
Expression régulière en Python
Expression régulière gourmande
Expression régulière re
Match de début / fin dans l'expression régulière python
Expression régulière en pymongo
Expression régulière de la notation de date
Expression régulière look-ahead, after-yomi
mémo d'expression régulière python
Méthode de correspondance d'expression régulière
Nom de groupe symbolique d'expression régulière en Python / Ruby
Quiz de confirmation d'expression régulière!
Utiliser l'expression let en Python
Notes sur l'expression régulière de la théorie Python
Utiliser des expressions régulières en C
Julia Quick Note [04] Expression régulière
Manipulation d'expressions régulières par Python
Résumé de l'outil de vérification des expressions régulières
Reproduire l'expression canonique Python r '\ w (? U)' en JavaScript
Comment obtenir toutes les valeurs possibles dans une expression régulière
Décomposer le nom d'hôte avec co.jp avec une expression régulière
Remplacement de chaîne par une expression régulière Python
100 Language Processing Knock 2020: Chapitre 3 (expression régulière)
Lors de l'utilisation d'expressions régulières en Python
Caractéristiques des modules d'expressions régulières qui sont souvent utilisés personnellement en Python
Qu'y a-t-il dans le paramètre? Modifier la chaîne et l'expression
Utiliser l'impression dans l'expression lambda Python2
(Python) Remarques sur la lecture de HTML et l'utilisation d'expressions régulières
Remplacer non-ASCII par des expressions régulières en Python
N'utilisez pas \ d dans les expressions régulières Python 3!
Rechercher une clé de dictionnaire pythondict par expression régulière
Comment utiliser les expressions régulières en Python