问题
如何在 C++（或 C）中将所有重音字母更改为普通字母？
那样的话，我的意思是eéèêaàäâçc会变成eeeeaaaacc.
我已经尝试过的
我试过手动解析字符串并一个一个地替换它们，但我认为必须有一种我不知道的更好/更简单的方法（这样可以保证我不会忘记任何重音字母） .
我想知道标准库中是否已经有一个映射，或者是否所有重音字符都可以使用一些数学函数（例如floor(charCode-131/5) + 61)）轻松映射到“正常”字母。
问问题
12468 次
7 回答
12
char* removeAccented( char* str ) {
char *p = str;
while ( (*p)!=0 ) {
const char*
// "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ"
tr = "AAAAAAECEEEEIIIIDNOOOOOx0UUUUYPsaaaaaaeceeeeiiiiOnooooo/0uuuuypy";
unsigned char ch = (*p);
if ( ch >=192 ) {
(*p) = tr[ ch-192 ];
}
++p; // http://stackoverflow.com/questions/14094621/
}
return str;
}
于 2013-12-06T17:03:35.483 回答
7
我只在理论上知道。基本上，您执行 Unicode 规范化，然后进行一些分解，清除所有变音符号，然后重新组合。
于 2012-12-30T21:05:08.097 回答
7
您应该首先定义“重音字母”的含义，如果您所拥有的是一些扩展的 8 位 ASCII 以及高于 128 的代码的国家代码页，或者说一些 utf8 编码的字符串，那么必须做的事情会有很大不同。
但是，您应该看看libicu，它提供了良好的基于 unicode 的重音字母操作所必需的内容。
但它不会为你解决所有问题。例如，如果您收到一些中文或俄文信件，您应该怎么做？如果你得到土耳其大写字母 I 该怎么办？去掉这个“我”上的点？这样做会改变文本的含义......等等。这种问题对于unicode来说是无穷无尽的。即使是传统的排序顺序也取决于国家...
于 2012-12-30T22:08:39.730 回答
2
假设值只是chars，我将创建一个具有所需目标值的数组，然后将每个字符替换为数组中的相应成员：
char replacement[256];
int n(0);
std::generate_n(replacement, 256, [=]() mutable -> unsigned char { return n++; });
replacement[static_cast<unsigned char>('é')] = 'e';
// ...
std::transform(s.begin(), s.end(), s.begin(),
[&](unsigned char c){ return replacement[c]; });
由于问题也用 C 标记：使用 C 时，您需要创建合适的循环来执行相同的操作，但从概念上讲，它只是以相同的方式。同样，如果您不能使用 C++ 2011，您只需使用合适的函数对象而不是 lambda 函数。
显然，replacement阵列可以只设置一次，并且使用比上面概述的更智能的方法。但是，该原则应该有效。但是，如果您需要替换 Unicode 字符，事情会变得更有趣：一方面，数组会相当大，此外，字符可能需要更改多个单词。
于 2012-12-30T21:15:04.680 回答
1
以下是您可以使用ISO/IEC 8859-1（基于 ASCII 的标准字符编码）执行的操作：
- 如果代码范围是从
192 - 197替换为A - 如果代码范围是从
224 - 229替换为a - 如果代码范围是从
200 - 203替换为E - 如果代码范围是从
232 - 235替换为e - 如果代码范围是从
204 - 207替换为I - 如果代码范围是从
236 - 239替换为i - 如果代码范围是从
210 - 214替换为O - 如果代码范围是从
242 - 246替换为o - 如果代码范围是从
217 - 220替换为U - 如果代码范围是从
249 - 252替换为u
假设 x 是数字的代码，对大写字母执行以下操作：
y = floor((x - 192) / 6)- 如果
y <= 2那么z = ((y + 1) * 4) + 61否则z = (y * 6) + 61
对小写字母执行以下操作：
y = floor((x - 224) / 6)- 如果
y <= 2那么z = ((y + 1) * 4) + 93否则z = (y * 6) + 93
最终答案z是所需字母表的 ASCII 码。
请注意，此方法仅在您使用ISO/IEC 8859-1时有效。
于 2012-12-30T21:47:51.967 回答
1
恐怕这里没有捷径可走。
在应用程序中，我使用内部代码页表解决了这个问题，每个代码页表（如 1250、1251、1252 等）都包含实际的代码页字母和非变音符号等效项。表是使用 c# 自动生成的，它包含一些真正让这变得容易的类（实际上有一些启发式方法），java 也允许快速实现它。
这实际上是用于带有代码页的多字节数据，但它可以用于 UNICODE 字符串（只需在所有表中搜索给定的 unicode 字母）。
于 2012-12-30T22:23:17.407 回答
0
我的用例需要对一长串字符串进行不区分大小写的排序，其中一些字符串可能有变音符号。因此，例如，我希望“Añasco Municipio”出现在“Anchorage Municipality”之前，而不是在“Abbeville County”之前出现，因为它正在做一个幼稚的比较。
我的字符串是用 UTF-8 编码的，但它们有可能包含一些扩展的 ascii 字符，而不是正确的 UTF-8 Unicode。我本可以将所有字符串都升级为 UTF-8，然后使用一个可以进行 UTF-8 字符串比较的库，但我希望能够完全控制速度和决定如何将变音字符映射到非变音字符。（我的选择包括将阳性序数指示符视为“o”，将版权字符视为 c。）
下面的“双字节”代码是 UTF-8 序列。“单字节”代码扩展为 ascii。
这是我得到代码的地方：
http://www.endmemo.com/unicode/unicodeconverter.php
void SimplifyStringForSorting( string *s, bool changeToLowerCase )
{
// C0 C1 C2 C3 C4 C5 E0 E1 E2 E3 E4 E5 AA // one-byte codes for "a"
// C3 80 C3 81 C3 82 C3 83 C3 84 C3 85 C3 A0 C3 A1 C3 A2 C3 A3 C3 A4 C3 A5 C2 AA // two-byte codes for "a"
// C8 C9 CA CB E8 E9 EA EB // one-byte codes for "e"
// C3 88 C3 89 C3 8A C3 8B C3 A8 C3 A9 C3 AA C3 AB // two-byte codes for "e"
// CC CD CE CF EC ED EE EF // one-byte codes for "i"
// C3 8C C3 8D C3 8E C3 8F C3 AC C3 AD C3 AE C3 AF // two-byte codes for "i"
// D2 D3 D4 D5 D6 F2 F3 F4 F5 F6 BA // one-byte codes for "o"
// C3 92 C3 93 C3 94 C3 95 C3 96 C3 B2 C3 B3 C3 B4 C3 B5 C3 B6 C2 BA // two-byte codes for "o"
// D9 DA DB DC F9 FA FB FC // one-byte codes for "u"
// C3 99 C3 9A C3 9B C3 9C C3 B9 C3 BA C3 BB C3 BC // two-byte codes for "u"
// A9 C7 E7 // one-byte codes for "c"
// C2 A9 C3 87 C3 A7 // two-byte codes for "c"
// D1 F1 // one-byte codes for "n"
// C3 91 C3 B1 // two-byte codes for "n"
// AE // one-byte codes for "r"
// C2 AE // two-byte codes for "r"
// DF // one-byte codes for "s"
// C3 9F // two-byte codes for "s"
// 8E 9E // one-byte codes for "z"
// C5 BD C5 BE // two-byte codes for "z"
// 9F DD FD FF // one-byte codes for "y"
// C5 B8 C3 9D C3 BD C3 BF // two-byte codes for "y"
int n = s->size();
int pos = 0;
for ( int i = 0 ; i < n ; i++, pos++ )
{
unsigned char c = (unsigned char)s->at( i );
if ( c >= 0x80 )
{
if ( i < ( n - 1 ) && (unsigned char)s->at( i + 1 ) >= 0x80 )
{
unsigned char c2 = SimplifyDoubleCharForSorting( c, (unsigned char)s->at( i + 1 ), changeToLowerCase );
if ( c2 < 0x80 )
{
s->at( pos ) = c2;
i++;
}
else
{
// s->at( pos ) = SimplifySingleCharForSorting( c, changeToLowerCase );
// if it's a double code we don't recognize, skip both characters;
// this does mean that we lose the chance to handle back-to-back extended ascii characters
// but we'll assume that is less likely than a unicode "combining character" or other
// unrecognized unicode character for data
i++;
}
}
else
{
unsigned char c2 = SimplifySingleCharForSorting( c, changeToLowerCase );
if ( c2 < 0x80 )
{
s->at( pos );
}
else
{
// skip unrecognized single-byte codes
pos--;
}
}
}
else
{
if ( changeToLowerCase && c >= 'A' && c <= 'Z' )
{
s->at( pos ) = c + ( 'a' - 'A' );
}
else
{
s->at( pos ) = c;
}
}
}
if ( pos < n )
{
s->resize( pos );
}
}
unsigned char SimplifyDoubleCharForSorting( unsigned char c1, unsigned char c2, bool changeToLowerCase )
{
// C3 80 C3 81 C3 82 C3 83 C3 84 C3 85 C3 A0 C3 A1 C3 A2 C3 A3 C3 A4 C3 A5 C2 AA // two-byte codes for "a"
// C3 88 C3 89 C3 8A C3 8B C3 A8 C3 A9 C3 AA C3 AB // two-byte codes for "e"
// C3 8C C3 8D C3 8E C3 8F C3 AC C3 AD C3 AE C3 AF // two-byte codes for "i"
// C3 92 C3 93 C3 94 C3 95 C3 96 C3 B2 C3 B3 C3 B4 C3 B5 C3 B6 C2 BA // two-byte codes for "o"
// C3 99 C3 9A C3 9B C3 9C C3 B9 C3 BA C3 BB C3 BC // two-byte codes for "u"
// C2 A9 C3 87 C3 A7 // two-byte codes for "c"
// C3 91 C3 B1 // two-byte codes for "n"
// C2 AE // two-byte codes for "r"
// C3 9F // two-byte codes for "s"
// C5 BD C5 BE // two-byte codes for "z"
// C5 B8 C3 9D C3 BD C3 BF // two-byte codes for "y"
if ( c1 == 0xC2 )
{
if ( c2 == 0xAA ) { return 'a'; }
if ( c2 == 0xBA ) { return 'o'; }
if ( c2 == 0xA9 ) { return 'c'; }
if ( c2 == 0xAE ) { return 'r'; }
}
if ( c1 == 0xC3 )
{
if ( c2 >= 0x80 && c2 <= 0x85 ) { return changeToLowerCase ? 'a' : 'A'; }
if ( c2 >= 0xA0 && c2 <= 0xA5 ) { return 'a'; }
if ( c2 >= 0x88 && c2 <= 0x8B ) { return changeToLowerCase ? 'e' : 'E'; }
if ( c2 >= 0xA8 && c2 <= 0xAB ) { return 'e'; }
if ( c2 >= 0x8C && c2 <= 0x8F ) { return changeToLowerCase ? 'i' : 'I'; }
if ( c2 >= 0xAC && c2 <= 0xAF ) { return 'i'; }
if ( c2 >= 0x92 && c2 <= 0x96 ) { return changeToLowerCase ? 'o' : 'O'; }
if ( c2 >= 0xB2 && c2 <= 0xB6 ) { return 'o'; }
if ( c2 >= 0x99 && c2 <= 0x9C ) { return changeToLowerCase ? 'u' : 'U'; }
if ( c2 >= 0xB9 && c2 <= 0xBC ) { return 'u'; }
if ( c2 == 0x87 ) { return changeToLowerCase ? 'c' : 'C'; }
if ( c2 == 0xA7 ) { return 'c'; }
if ( c2 == 0x91 ) { return changeToLowerCase ? 'n' : 'N'; }
if ( c2 == 0xB1 ) { return 'n'; }
if ( c2 == 0x9F ) { return 's'; }
if ( c2 == 0x9D ) { return changeToLowerCase ? 'y' : 'Y'; }
if ( c2 == 0xBD || c2 == 0xBF ) { return 'y'; }
}
if ( c1 == 0xC5 )
{
if ( c2 == 0xBD ) { return changeToLowerCase ? 'z' : 'Z'; }
if ( c2 == 0xBE ) { return 'z'; }
if ( c2 == 0xB8 ) { return changeToLowerCase ? 'y' : 'Y'; }
}
return c1;
}
unsigned char SimplifySingleCharForSorting( unsigned char c, bool changeToLowerCase )
{
// C0 C1 C2 C3 C4 C5 E0 E1 E2 E3 E4 E5 AA // one-byte codes for "a"
// C8 C9 CA CB E8 E9 EA EB // one-byte codes for "e"
// CC CD CE CF EC ED EE EF // one-byte codes for "i"
// D2 D3 D4 D5 D6 F2 F3 F4 F5 F6 BA // one-byte codes for "o"
// D9 DA DB DC F9 FA FB FC // one-byte codes for "u"
// A9 C7 E7 // one-byte codes for "c"
// D1 F1 // one-byte codes for "n"
// AE // one-byte codes for "r"
// DF // one-byte codes for "s"
// 8E 9E // one-byte codes for "z"
// 9F DD FD FF // one-byte codes for "y"
if ( ( c >= 0xC0 && c <= 0xC5 ) || ( c >= 0xE1 && c <= 0xE5 ) || c == 0xAA )
{
return ( ( c >= 0xC0 && c <= 0xC5 ) && !changeToLowerCase ) ? 'A' : 'a';
}
if ( ( c >= 0xC8 && c <= 0xCB ) || ( c >= 0xE8 && c <= 0xEB ) )
{
return ( c > 0xCB || changeToLowerCase ) ? 'e' : 'E';
}
if ( ( c >= 0xCC && c <= 0xCF ) || ( c >= 0xEC && c <= 0xEF ) )
{
return ( c > 0xCF || changeToLowerCase ) ? 'i' : 'I';
}
if ( ( c >= 0xD2 && c <= 0xD6 ) || ( c >= 0xF2 && c <= 0xF6 ) || c == 0xBA )
{
return ( ( c >= 0xD2 && c <= 0xD6 ) && !changeToLowerCase ) ? 'O' : 'o';
}
if ( ( c >= 0xD9 && c <= 0xDC ) || ( c >= 0xF9 && c <= 0xFC ) )
{
return ( c > 0xDC || changeToLowerCase ) ? 'u' : 'U';
}
if ( c == 0xA9 || c == 0xC7 || c == 0xE7 )
{
return ( c == 0xC7 && !changeToLowerCase ) ? 'C' : 'c';
}
if ( c == 0xD1 || c == 0xF1 )
{
return ( c == 0xD1 && !changeToLowerCase ) ? 'N' : 'n';
}
if ( c == 0xAE )
{
return 'r';
}
if ( c == 0xDF )
{
return 's';
}
if ( c == 0x8E || c == 0x9E )
{
return ( c == 0x8E && !changeToLowerCase ) ? 'Z' : 'z';
}
if ( c == 0x9F || c == 0xDD || c == 0xFD || c == 0xFF )
{
return ( ( c == 0x9F || c == 0xDD ) && !changeToLowerCase ) ? 'Y' : 'y';
}
return c;
}
于 2016-07-02T01:50:13.377 回答