是否有strstr的反向function
我试图找到一个类似于strstr函数，它搜索从字符串开头到字符串开头的子字符串。
我不知道一个。 关于C的一个好处是，如果你编写自己的函数，它就像库函数一样快速有效。 （在许多其他语言中情况并非如此。）
您可以反转字符串和子字符串，然后搜索。
最后，当字符串库不够好时，人们经常做的另一件事就是转移到正则表达式。
好吧，我写了reverse()和rstrstr() ，如果幸运的话可能会有效。 为C ++摆脱__restrict 。 您也可能想要使参数为const ，但是您需要转换返回值。 要回答您的评论问题，您可以通过从中减去原始字符串指针来从子字符串的地址获取索引。 好：
#include #include char *reverse(const char * __restrict const s) { if (s == NULL) return NULL; size_t i, len = strlen(s); char *r = malloc(len + 1); for(i = 0; i < len; ++i) r[i] = s[len - i - 1]; r[len] = 0; return r; } char *rstrstr(char *__restrict s1, char *__restrict s2) { size_t s1len = strlen(s1); size_t s2len = strlen(s2); char *s; if (s2len > s1len) return NULL; for (s = s1 + s1len - s2len; s >= s1; --s) if (strncmp(s, s2, s2len) == 0) return s; return NULL; }
标准C库没有“反向strstr”function，因此您必须自己查找或编写。
我想出了我自己的几个解决方案，并在此线程中添加了一些测试和基准测试代码以及其他函数。 对于那些好奇的，在我的笔记本电脑上运行（Ubuntu karmic，amd64架构），输出看起来像这样：
$ gcc -O2 --std=c99 strrstr.c && ./a.out #1 0.123 us last_strstr #2 0.440 us theo #3 0.460 us cordelia #4 1.690 us digitalross #5 7.700 us backwards_memcmp #6 8.600 us sinan
您的结果可能会有所不同，并且根据您的编译器和库，结果的顺序也可能不同。
要从字符串的开头获取匹配的偏移量（索引），请使用指针算术：
char *match = last_strstr(haystack, needle); ptrdiff_t index; if (match != NULL) index = match - haystack; else index = -1;
现在，落叶松（请注意，这纯粹是在C中，我不太了解C ++，无法给出答案）：
/* * In response to * http://stackoverflow.com/questions/1634359/is-there-a-reverse-fn-for-strstr * * Basically, strstr but return last occurence, not first. * * This file contains several implementations and a harness to test and * benchmark them. * * Some of the implementations of the actual function are copied from * elsewhere; they are commented with the location. The rest of the coe * was written by Lars Wirzenius (liw@liw.fi) and is hereby released into * the public domain. No warranty. If it turns out to be broken, you get * to keep the pieces. */ #include #include /* By liw. */ static char *last_strstr(const char *haystack, const char *needle) { if (*needle == '\0') return (char *) haystack; char *result = NULL; for (;;) { char *p = strstr(haystack, needle); if (p == NULL) break; result = p; haystack = p + 1; } return result; } /* By liw. */ static char *backwards_memcmp(const char *haystack, const char *needle) { size_t haylen = strlen(haystack); if (*needle == '\0') return (char *) haystack; size_t needlelen = strlen(needle); if (needlelen > haylen) return NULL; const char *p = haystack + haylen - needlelen; for (;;) { if (memcmp(p, needle, needlelen) == 0) return (char *) p; if (p == haystack) return NULL; --p; } } /* From http://stuff.mit.edu/afs/sipb/user/cordelia/Diplomacy/mapit/strrstr.c */ static char *cordelia(const char *s1, const char *s2) { const char *sc1, *sc2, *psc1, *ps1; if (*s2 == '\0') return((char *)s1); ps1 = s1 + strlen(s1); while(ps1 != s1) { --ps1; for (psc1 = ps1, sc2 = s2; ; ) if (*(psc1++) != *(sc2++)) break; else if (*sc2 == '\0') return ((char *)ps1); } return ((char *)NULL); } /* From http://stackoverflow.com/questions/1634359/ is-there-a-reverse-fn-for-strstr/1634398#1634398 (DigitalRoss). */ static char *reverse(const char *s) { if (s == NULL) return NULL; size_t i, len = strlen(s); char *r = malloc(len + 1); for(i = 0; i < len; ++i) r[i] = s[len - i - 1]; r[len] = 0; return r; } char *digitalross(const char *s1, const char *s2) { size_t s1len = strlen(s1); size_t s2len = strlen(s2); const char *s; if (s2len == 0) return (char *) s1; if (s2len > s1len) return NULL; for (s = s1 + s1len - s2len; s >= s1; --s) if (strncmp(s, s2, s2len) == 0) return (char *) s; return NULL; } /* From http://stackoverflow.com/questions/1634359/ is-there-a-reverse-fn-for-strstr/1634487#1634487 (Sinan Ünür). */ char *sinan(const char *source, const char *target) { const char *current; const char *found = NULL; if (*target == '\0') return (char *) source; size_t target_length = strlen(target); current = source + strlen(source) - target_length; while ( current >= source ) { if ( (found = strstr(current, target)) ) { break; } current -= 1; } return (char *) found; } /* From http://stackoverflow.com/questions/1634359/ is-there-a-reverse-fn-for-strstr/1634441#1634441 (Theo Spears). */ char *theo(const char* haystack, const char* needle) { int needle_length = strlen(needle); const char* haystack_end = haystack + strlen(haystack) - needle_length; const char* p; size_t i; if (*needle == '\0') return (char *) haystack; for(p = haystack_end; p >= haystack; --p) { for(i = 0; i < needle_length; ++i) { if(p[i] != needle[i]) goto next; } return (char *) p; next:; } return 0; } /* * The rest of this code is a test and timing harness for the various * implementations above. */ #include #include #include #include /* Check that the given function works. */ static bool works(const char *name, char *(*func)(const char *, const char *)) { struct { const char *haystack; const char *needle; int offset; } tests[] = { { "", "", 0 }, { "", "x", -1 }, { "x", "", 0 }, { "x", "x", 0 }, { "xy", "x", 0 }, { "xy", "y", 1 }, { "xyx", "x", 2 }, { "xyx", "y", 1 }, { "xyx", "z", -1 }, { "xyx", "", 0 }, }; const int num_tests = sizeof(tests) / sizeof(tests[0]); bool ok = true; for (int i = 0; i < num_tests; ++i) { int offset; char *p = func(tests[i].haystack, tests[i].needle); if (p == NULL) offset = -1; else offset = p - tests[i].haystack; if (offset != tests[i].offset) { fprintf(stderr, "FAIL %s, test %d: returned %d, haystack = '%s', " "needle = '%s', correct return %d\n", name, i, offset, tests[i].haystack, tests[i].needle, tests[i].offset); ok = false; } } return ok; } /* Dummy function for calibrating the measurement loop. */ static char *dummy(const char *haystack, const char *needle) { return NULL; } /* Measure how long it will take to call the given function with the given arguments the given number of times. Return clock ticks. */ static clock_t repeat(char *(*func)(const char *, const char *), const char *haystack, const char *needle, long num_times) { clock_t start, end; start = clock(); for (long i = 0; i < num_times; ++i) { func(haystack, needle); } end = clock(); return end - start; } static clock_t min(clock_t a, clock_t b) { if (a < b) return a; else return b; } /* Measure the time to execute one call of a function, and return the number of CPU clock ticks (see clock(3)). */ static double timeit(char *(*func)(const char *, const char *)) { /* The arguments for the functions to be measured. We deliberately choose a case where the haystack is large and the needle is in the middle, rather than at either end. Obviously, any test data will favor some implementations over others. This is the weakest part of the benchmark. */ const char haystack[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "b" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; const char needle[] = "b"; /* First we find out how many repeats we need to do to get a sufficiently long measurement time. These functions are so fast that measuring only a small number of repeats will give wrong results. However, we don't want to do a ridiculously long measurement, either, so start with one repeat and multiply it by 10 until the total time is about 0.2 seconds. Finally, we measure the dummy function the same number of times to get rid of the call overhead. */ clock_t mintime = 0.2 * CLOCKS_PER_SEC; clock_t clocks; long repeats = 1; for (;;) { clocks = repeat(func, haystack, needle, repeats); if (clocks >= mintime) break; repeats *= 10; } clocks = min(clocks, repeat(func, haystack, needle, repeats)); clocks = min(clocks, repeat(func, haystack, needle, repeats)); clock_t dummy_clocks; dummy_clocks = repeat(dummy, haystack, needle, repeats); dummy_clocks = min(dummy_clocks, repeat(dummy, haystack, needle, repeats)); dummy_clocks = min(dummy_clocks, repeat(dummy, haystack, needle, repeats)); return (double) (clocks - dummy_clocks) / repeats / CLOCKS_PER_SEC; } /* Array of all functions. */ struct func { const char *name; char *(*func)(const char *, const char *); double secs; } funcs[] = { #define X(func) { #func, func, 0 } X(last_strstr), X(backwards_memcmp), X(cordelia), X(digitalross), X(sinan), X(theo), #undef X }; const int num_funcs = sizeof(funcs) / sizeof(funcs[0]); /* Comparison function for qsort, comparing timings. */ int funcmp(const void *a, const void *b) { const struct func *aa = a; const struct func *bb = b; if (aa->secs < bb->secs) return -1; else if (aa->secs > bb->secs) return 1; else return 0; } int main(void) { bool ok = true; for (int i = 0; i < num_funcs; ++i) { if (!works(funcs[i].name, funcs[i].func)) { fprintf(stderr, "%s does not work\n", funcs[i].name); ok = false; } } if (!ok) return EXIT_FAILURE; for (int i = 0; i < num_funcs; ++i) funcs[i].secs = timeit(funcs[i].func); qsort(funcs, num_funcs, sizeof(funcs[0]), funcmp); for (int i = 0; i < num_funcs; ++i) printf("#%d %.3f us %s\n", i+1, funcs[i].secs * 1e6, funcs[i].name); return 0; }
如果你可以使用C ++，你可以搜索这样的字符串：
std::string::iterator found=std::search(haystack.rbegin(), haystack.rend(), needle.rbegin(), needle.rend()).base(); // => yields haystack.begin() if not found, otherwise, an iterator past-the end of the occurence of needle
一个可能的，如果不是完全优雅的实现可能看起来像：
#include "string.h" const char* rstrstr(const char* haystack, const char* needle) { int needle_length = strlen(needle); const char* haystack_end = haystack + strlen(haystack) - needle_length; const char* p; size_t i; for(p = haystack_end; p >= haystack; --p) { for(i = 0; i < needle_length; ++i) { if(p[i] != needle[i]) goto next; } return p; next:; } return 0; }
不。这是C ++ std :: string类具有明显优势的地方之一 – 与std::string::find() ，还有std::string::rfind() 。
是否有一个C库函数来查找字符串中最后一个子串的索引？
编辑：正如@hhafez在下面的评论中指出的那样，我为此发布的第一个解决方案效率低且不正确（因为我通过target_length推进指针，这在我的愚蠢测试中运行良好）。 您可以在编辑历史记录中找到该版本。
这是一个从最后开始并返回的实现：
#include #include #include const char * findlast(const char *source, const char *target) { const char *current; const char *found = NULL; size_t target_length = strlen(target); current = source + strlen(source) - target_length; while ( current >= source ) { if ( (found = strstr(current, target)) ) { break; } current -= 1; } return found; } int main(int argc, char *argv[]) { if ( argc != 3 ) { fputs("invoke with source and search strings as arguments", stderr); return EXIT_FAILURE; } const char *found = findlast(argv[1], argv[2]); if ( found ) { printf("Last occurence of '%s' in '%s' is at offset %d\n", argv[2], argv[1], found - argv[1] ); } return 0; }
输出：
C：\ Temp> st“这是测试此测试的测试字符串 最近出现的'test'在'这是一个测试它的测试字符串'是 在抵消27
我认为您仍然可以使用库函数来完成它。
1.使用strrev函数来反转字符串。
2.使用strstr函数执行您想要执行的任何操作。
3.您可以通过从原始字符串的长度中减去搜索字符串的起始索引来查找搜索字符串的起始索引（从反向开始）。
虽然非标准， strrstr得到广泛支持，并且完全符合您的要求。
我不相信c字符串lib中存在，但是编写自己的字符串将是微不足道的。在一个条件下，您知道字符串的长度或它是否正确终止。
标准C库中没有一个。 您可以在网上找到一个，或者您可能需要自己编写。
长话短说：
不 – C库中没有function可以满足您的需求..
但正如其他人所指出的那样：写这样一个function并不是火箭科学……
这是一个。 测试它是我要留给你的一个练习:)
谢谢你的回答！ 还有一种方法来自MSDN论坛。 http://social.msdn.microsoft.com/Forums/en-US/vclanguage/thread/ed0f6ef9-8911-4879-accb-b3c778a09d94
char * strrstr(char *_Str, char *_SubStr){ char *returnPointer, *p; //find 1st occurence. if not found, return NULL if ( (p=strstr(_Str, _SubStr))==NULL) return NULL; //loop around until no more occurences do{ returnPointer=p; ++p; }while(p=strstr(p, _SubStr)); return returnPointer; }
为此，您可以使用标准算法std :: find_end。 例如
char s[] = "What is the last word last"; char t[] = "last"; std::cout << std::find_end( s, s + sizeof( s ) - 1, t, t + sizeof( t ) -1 ) << std::endl;
这是我能想到的最简单的简单植入。 与此函数的其他实现不同，它避免了像user3119703这样的其他人的初始strstr调用。
char * lastStrstr(const char * haystack,const char * needle){ char*temp=haystack,*before=0; while(temp=strstr(temp,needle)) before=temp++; return before; }
char* strrstr(char * _Str, const char * _SubStr) { const BYTE EQUAL=0; int i=0, src_len = strlen(_Str), find_len = strlen(_SubStr), tail_count=0; for(i=src_len; i>-1; i--) { if(_Str[i] == _SubStr[0] && tail_count >= find_len) { if(strncmp(&_Str[i], _SubStr, find_len) == EQUAL) { return &_Str[i]; } } tail_count++; } return NULL; }