LINUX.ORG.RU

Ответ на: комментарий от Fastman

проще wxBase( без гуя ) - весит меньше, так что можно статически линковать

Unknown
() 

Ня ;)
Проверку на переполнение буфера и NULLы не забудьте добавить ;)

static void cp1251_to_utf8(char *out, const char *in) {
    static const char table[128][4] = {
        "\2\xD0\x82","\2\xD0\x83","\3\xE2\x80\x9A","\2\xD1\x93",
        "\3\xE2\x80\x9E","\3\xE2\x80\xA6","\3\xE2\x80\xA0","\3\xE2\x80\xA1",
        "\3\xE2\x82\xAC","\3\xE2\x80\xB0","\2\xD0\x89","\3\xE2\x80\xB9",
        "\2\xD0\x8A","\2\xD0\x8C","\2\xD0\x8B","\2\xD0\x8F",
        "\2\xD1\x92","\3\xE2\x80\x98","\3\xE2\x80\x99","\3\xE2\x80\x9C",
        "\3\xE2\x80\x9D","\3\xE2\x80\xA2","\3\xE2\x80\x93","\3\xE2\x80\x94",
        "\0","\3\xE2\x84\xA2","\2\xD1\x99","\3\xE2\x80\xBA",
        "\2\xD1\x9A","\2\xD1\x9C","\2\xD1\x9B","\2\xD1\x9F",
        "\2\xC2\xA0","\2\xD0\x8E","\2\xD1\x9E","\2\xD0\x88",
        "\2\xC2\xA4","\2\xD2\x90","\2\xC2\xA6","\2\xC2\xA7",
        "\2\xD0\x81","\2\xC2\xA9","\2\xD0\x84","\2\xC2\xAB",
        "\2\xC2\xAC","\2\xC2\xAD","\2\xC2\xAE","\2\xD0\x87",
        "\2\xC2\xB0","\2\xC2\xB1","\2\xD0\x86","\2\xD1\x96",
        "\2\xD2\x91","\2\xC2\xB5","\2\xC2\xB6","\2\xC2\xB7",
        "\2\xD1\x91","\3\xE2\x84\x96","\2\xD1\x94","\2\xC2\xBB",
        "\2\xD1\x98","\2\xD0\x85","\2\xD1\x95","\2\xD1\x97",
        "\2\xD0\x90","\2\xD0\x91","\2\xD0\x92","\2\xD0\x93",
        "\2\xD0\x94","\2\xD0\x95","\2\xD0\x96","\2\xD0\x97",
        "\2\xD0\x98","\2\xD0\x99","\2\xD0\x9A","\2\xD0\x9B",
        "\2\xD0\x9C","\2\xD0\x9D","\2\xD0\x9E","\2\xD0\x9F",
        "\2\xD0\xA0","\2\xD0\xA1","\2\xD0\xA2","\2\xD0\xA3",
        "\2\xD0\xA4","\2\xD0\xA5","\2\xD0\xA6","\2\xD0\xA7",
        "\2\xD0\xA8","\2\xD0\xA9","\2\xD0\xAA","\2\xD0\xAB",
        "\2\xD0\xAC","\2\xD0\xAD","\2\xD0\xAE","\2\xD0\xAF",
        "\2\xD0\xB0","\2\xD0\xB1","\2\xD0\xB2","\2\xD0\xB3",
        "\2\xD0\xB4","\2\xD0\xB5","\2\xD0\xB6","\2\xD0\xB7",
        "\2\xD0\xB8","\2\xD0\xB9","\2\xD0\xBA","\2\xD0\xBB",
        "\2\xD0\xBC","\2\xD0\xBD","\2\xD0\xBE","\2\xD0\xBF",
        "\2\xD1\x80","\2\xD1\x81","\2\xD1\x82","\2\xD1\x83",
        "\2\xD1\x84","\2\xD1\x85","\2\xD1\x86","\2\xD1\x87",
        "\2\xD1\x88","\2\xD1\x89","\2\xD1\x8A","\2\xD1\x8B",
        "\2\xD1\x8C","\2\xD1\x8D","\2\xD1\x8E","\2\xD1\x8F"
    };
    while (*in) {
        if (*in & 0x80) {
            const char *p = table[(int)(0x7f & *in++)];
            if (!*p)
                continue;
            *out++ = p[1];
            if (*p == 1)
                continue;
            *out++ = p[2];
            if (*p == 2)
                continue;
            *out++ = p[3];
        }
        else
            *out++ = *in++;
    }
    *out = 0;
}

arsi ★★★★★
() 

void cp2utf( char* str, char* res ) {
	static const short utf[ 256 ] = {
		0,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe,0xf,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
		0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,
		0x27,0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0x34,0x35,0x36,
		0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
		0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0x53,0x54,0x55,0x56,
		0x57,0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,0x61,0x62,0x63,0x64,0x65,0x66,
		0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,
		0x77,0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f,0x402,0x403,0x201a,0x453,0x201e,
		0x2026,0x2020,0x2021,0x20ac,0x2030,0x409,0x2039,0x40a,0x40c,0x40b,0x40f,0x452,
		0x2018,0x2019,0x201c,0x201d,0x2022,0x2013,0x2014,0,0x2122,0x459,0x203a,0x45a,
		0x45c,0x45b,0x45f,0xa0,0x40e,0x45e,0x408,0xa4,0x490,0xa6,0xa7,0x401,0xa9,0x404,
		0xab,0xac,0xad,0xae,0x407,0xb0,0xb1,0x406,0x456,0x491,0xb5,0xb6,0xb7,0x451,
		0x2116,0x454,0xbb,0x458,0x405,0x455,0x457,0x410,0x411,0x412,0x413,0x414,0x415,
		0x416,0x417,0x418,0x419,0x41a,0x41b,0x41c,0x41d,0x41e,0x41f,0x420,0x421,0x422,
		0x423,0x424,0x425,0x426,0x427,0x428,0x429,0x42a,0x42b,0x42c,0x42d,0x42e,0x42f,
		0x430,0x431,0x432,0x433,0x434,0x435,0x436,0x437,0x438,0x439,0x43a,0x43b,0x43c,
		0x43d,0x43e,0x43f,0x440,0x441,0x442,0x443,0x444,0x445,0x446,0x447,0x448,0x449,
		0x44a,0x44b,0x44c,0x44d,0x44e,0x44f
	};

	int cnt = strlen( str ),
	i = 0, j = 0;
	for(; i < cnt; ++i ) {
		unsigned short c = utf[ (unsigned char) str[ i ] ];
		if( c < 0x80 ) {
			res[ j++ ] = c;
		}
		else if( c < 0x800 ) {
			res[ j++ ] =  c >> 6 | 0xc0;
			res[ j++ ] = c & 0x3f | 0x80;
		}
	}
	res[ j ] = '\0';
}

summatus ★
()
Ответ на: комментарий от andreyu

> А чем mbstowcs(wdst, src, size) не устраивает? Или обязательно нужно из stl?

Млин, вам нужно в UTF8, а не из MBS в WS.

andreyu ★★★★★
()
Ответ на: комментарий от summatus

> cp2utf

1. Символ с кодом 155 заменяется на '\0', что не есть гут. 2. Все символы, которые в UTF-8 кодируются более чем двумя байтами, отжираются напрочь. Какая-то выборочная конвертация. Это тоже не гут.

Работай над ошибками.

zzf
() 

void cp2utf( char* str, char* res ) {
	static const long utf[ 256 ] = {
		0,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,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,
		87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,
		111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,1026,1027,8218,
		1107,8222,8230,8224,8225,8364,8240,1033,8249,1034,1036,1035,1039,1106,8216,8217,
		8220,8221,8226,8211,8212,8250,8482,1113,8250,1114,1116,1115,1119,160,1038,1118,1032,
		164,1168,166,167,1025,169,1028,171,172,173,174,1031,176,177,1030,1110,1169,181,182,
		183,1105,8470,1108,187,1112,1029,1109,1111,1040,1041,1042,1043,1044,1045,1046,1047,
		1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,
		1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,
		1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,
		1096,1097,1098,1099,1100,1101,1102,1103
	};

	int cnt = strlen( str ),
	i = 0, j = 0;

	for(; i < cnt; ++i ) {
		long c = utf[ (unsigned char) str[ i ] ];
		if( c < 0x80 ) {
			res[ j++ ] = c;
		}
		else if( c < 0x800 ) {
			res[ j++ ] = c >> 6 | 0xc0;
			res[ j++ ] = c & 0x3f | 0x80;
		} 
		else if( c < 0x10000 ) {
			res[ j++ ] = c >> 12 | 0xe0;
			res[ j++ ] = c >> 6 & 0x3f | 0x80;
			res[ j++ ] = c & 0x3f | 0x80;
		} 
		else if( c < 0x200000 ) {
			res[ j++ ] = c >> 18 | 0xf0;
			res[ j++ ] = c >> 12 & 0x3f | 0x80;
			res[ j++ ] = c >> 6 & 0x3f | 0x80;
			res[ j++ ] = c & 0x3f | 0x80;
		}
	}
	res[ j ] = '\0';
}

summatus ★
()
Ответ на: комментарий от summatus

> Правая одинарная кавычка

… имеет код 155 и нормально конвертируется (только что проверил). говорю, 152-го символа не существует, и в моём примере он (единственный) пропускается.

arsi ★★★★★
()
Ответ на: комментарий от arsi 

да, раз уж пошла такая пьянка, то и я кот немножко упрощу (+паршивенький примерчик):

#include <stdio.h>                                             

static void cp1251_to_utf8(char *out, const char *in) {
    static const char table[128*3] = {                 
        "\320\202 \320\203 \342\200\232\321\223 \342\200\236\342\200\246\342\200\240\342\200\241"
        "\342\202\254\342\200\260\320\211 \342\200\271\320\212 \320\214 \320\213 \320\217 "      
        "\321\222 \342\200\230\342\200\231\342\200\234\342\200\235\342\200\242\342\200\223\342\200\224"
        "   \342\204\242\321\231 \342\200\272\321\232 \321\234 \321\233 \321\237 "                     
        "\302\240 \320\216 \321\236 \320\210 \302\244 \322\220 \302\246 \302\247 "                     
        "\320\201 \302\251 \320\204 \302\253 \302\254 \302\255 \302\256 \320\207 "                     
        "\302\260 \302\261 \320\206 \321\226 \322\221 \302\265 \302\266 \302\267 "
        "\321\221 \342\204\226\321\224 \302\273 \321\230 \320\205 \321\225 \321\227 "
        "\320\220 \320\221 \320\222 \320\223 \320\224 \320\225 \320\226 \320\227 "
        "\320\230 \320\231 \320\232 \320\233 \320\234 \320\235 \320\236 \320\237 "
        "\320\240 \320\241 \320\242 \320\243 \320\244 \320\245 \320\246 \320\247 "
        "\320\250 \320\251 \320\252 \320\253 \320\254 \320\255 \320\256 \320\257 "
        "\320\260 \320\261 \320\262 \320\263 \320\264 \320\265 \320\266 \320\267 "
        "\320\270 \320\271 \320\272 \320\273 \320\274 \320\275 \320\276 \320\277 "
        "\321\200 \321\201 \321\202 \321\203 \321\204 \321\205 \321\206 \321\207 "
        "\321\210 \321\211 \321\212 \321\213 \321\214 \321\215 \321\216 \321\217 "
    };
    while (*in)
        if (*in & 0x80) {
            const char *p = &table[3 * (0x7f & *in++)];
            if (*p == ' ')
                continue;
            *out++ = *p++;
            *out++ = *p++;
            if (*p == ' ')
                continue;
            *out++ = *p++;
        }
        else
            *out++ = *in++;
    *out = 0;
}

int main() {
    int c;
    while ((c = getchar()) != EOF) {
        char buf[4], in[2] = {0, 0};
        *in = c;
        cp1251_to_utf8(buf, in);
        printf("%s", buf);
    }
    return 0;
}

---------------------------------------------

$ cc -ansi -pedantic-errors cp1251_to_utf8.c -o cp1251_to_utf8

$ perl -E 'say map{chr}128..255' | iconv -t latin1 | ./cp1251_to_utf8 
ЂЃ‚ѓ„…†‡€‰Љ‹ЊЌЋЏђ‘’“”•–—™љ›њќћџ ЎўЈ¤Ґ¦§Ё©Є«¬­®Ї°±Ііґµ¶·ё№є»јЅѕїАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя

$ perl -E 'say map{chr}128..255' | iconv -t latin1 | iconv -c -f cp1251                      
ЂЃ‚ѓ„…†‡€‰Љ‹ЊЌЋЏђ‘’“”•–—™љ›њќћџ ЎўЈ¤Ґ¦§Ё©Є«¬­®Ї°±Ііґµ¶·ё№є»јЅѕїАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя

100% совпадение с iconv ;)

arsi ★★★★★
()
Ответ на: комментарий от summatus

> Это намёк, что у меня не 100%? =)

не-а. это намёк, что у меня ничего нужного не теряется и ничего лишнего не добавляется. не нужно искать скрытый смысл там, где его нет ;)

arsi ★★★★★
()
Ответ на: комментарий от arsi 

А моя быстрее на 20% =) И, кстати, сабж то c++

#include <stdio.h>
#include <string.h>
#include <time.h>

static void cp1251_to_utf8(char *out, const char *in) {
    static const char table[128*3] = {                 
        "\320\202 \320\203 \342\200\232\321\223 \342\200\236\342\200\246\342\200\240\342\200\241"
        "\342\202\254\342\200\260\320\211 \342\200\271\320\212 \320\214 \320\213 \320\217 "      
        "\321\222 \342\200\230\342\200\231\342\200\234\342\200\235\342\200\242\342\200\223\342\200\224"
        "   \342\204\242\321\231 \342\200\272\321\232 \321\234 \321\233 \321\237 "                     
        "\302\240 \320\216 \321\236 \320\210 \302\244 \322\220 \302\246 \302\247 "                     
        "\320\201 \302\251 \320\204 \302\253 \302\254 \302\255 \302\256 \320\207 "                     
        "\302\260 \302\261 \320\206 \321\226 \322\221 \302\265 \302\266 \302\267 "
        "\321\221 \342\204\226\321\224 \302\273 \321\230 \320\205 \321\225 \321\227 "
        "\320\220 \320\221 \320\222 \320\223 \320\224 \320\225 \320\226 \320\227 "
        "\320\230 \320\231 \320\232 \320\233 \320\234 \320\235 \320\236 \320\237 "
        "\320\240 \320\241 \320\242 \320\243 \320\244 \320\245 \320\246 \320\247 "
        "\320\250 \320\251 \320\252 \320\253 \320\254 \320\255 \320\256 \320\257 "
        "\320\260 \320\261 \320\262 \320\263 \320\264 \320\265 \320\266 \320\267 "
        "\320\270 \320\271 \320\272 \320\273 \320\274 \320\275 \320\276 \320\277 "
        "\321\200 \321\201 \321\202 \321\203 \321\204 \321\205 \321\206 \321\207 "
        "\321\210 \321\211 \321\212 \321\213 \321\214 \321\215 \321\216 \321\217 "
    };
    while (*in)
        if (*in & 0x80) {
            const char *p = &table[3 * (0x7f & *in++)];
            if (*p == ' ')
                continue;
            *out++ = *p++;
            *out++ = *p++;
            if (*p == ' ')
                continue;
            *out++ = *p++;
        }
        else
            *out++ = *in++;
    *out = 0;
}

void cp2utf( char* str, char* res ) {
	static const long utf[ 256 ] = {
		0,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,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,
		87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,
		111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,1026,1027,8218,
		1107,8222,8230,8224,8225,8364,8240,1033,8249,1034,1036,1035,1039,1106,8216,8217,
		8220,8221,8226,8211,8212,8250,8482,1113,8250,1114,1116,1115,1119,160,1038,1118,1032,
		164,1168,166,167,1025,169,1028,171,172,173,174,1031,176,177,1030,1110,1169,181,182,
		183,1105,8470,1108,187,1112,1029,1109,1111,1040,1041,1042,1043,1044,1045,1046,1047,
		1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,
		1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,
		1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,
		1096,1097,1098,1099,1100,1101,1102,1103
	};

	int cnt = strlen( str ),
	i = 0, j = 0;

	for(; i < cnt; ++i ) {
		long c = utf[ (unsigned char) str[ i ] ];
		if( c < 0x80 ) {
			res[ j++ ] = c;
		}
		else if( c < 0x800 ) {
			res[ j++ ] = c >> 6 | 0xc0;
			res[ j++ ] = c & 0x3f | 0x80;
		} 
		else if( c < 0x10000 ) {
			res[ j++ ] = c >> 12 | 0xe0;
			res[ j++ ] = c >> 6 & 0x3f | 0x80;
			res[ j++ ] = c & 0x3f | 0x80;
		} 
	}
	res[ j ] = '\0';
}

int main() {
	char str[] = "ЂЃ‚ѓ„…†‡€‰Љ‹ЊЌЋЏђ‘’“”•–—™љ›њќћџ ЎўЈ¤Ґ¦§Ё©Є«¬­®Ї°±Ііґµ¶·ё№є»јЅѕїАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя";
	char res[ sizeof( str ) * 3 + 1 ];
	
	clock_t t1 = clock(), t2;
	int i = 0;
	for(; i < 10000000; ++i ) {
		cp2utf( (char*) &str, (char*) &res );
	}

	printf( "%s\n\n", res );

	t2 = clock();
	float time1 = ( 1.f * ( t2 - t1 ) ) / CLOCKS_PER_SEC;
	printf( "%.2f\n", time1 );

	t1 = clock();
	for( i = 0; i < 10000000; ++i ) {
		cp1251_to_utf8( (char*) &res, (const char*) &str );
	}

	t2 = clock();
	float time2 = ( 1.f * ( t2 - t1 ) ) / CLOCKS_PER_SEC;
	printf( "%.2f\n",  time2 );

	printf( "%d\n", (int) ( ( time2 / time1 ) * 100 - 100 ) );
}


~/src/tmp$ gcc -O2 cp.c -o o && ./o
ЂЃ‚ѓ„…†‡€‰Љ‹ЊЌЋЏђ‘’“”•–—™љ›њќћџ ЎўЈ¤Ґ¦§Ё©Є«¬­®Ї°±Ііґµ¶·ё№є»јЅѕїАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯабвгдежзийклмнопрстуфхцчшщъыьэюя

4.84
5.86
21

summatus ★
()
Ответ на: комментарий от arsi

> 152 же… (0х98)

Точ! 152. Я опечатался, скажем так. Молоток. Пиши ещё.

zzf
()
Ответ на: комментарий от zzf 

> Можешь быть ещё быстрее, если не будешь два раза по строчке бегать. 

ну, это не главное… наверное.
а вот каждый раз переводить utf16→utf8 — да, зря.

у меня, кстати, тормозило из-за дурного обращения к памяти,
тогда как действительно можно было прочитать раз и дальше работать с регистрами:

static void cp1251_to_utf8(char *out, const char *in) {
    static const int table[128] = {                    
        0x82D0,0x83D0,0x9A80E2,0x93D1,0x9E80E2,0xA680E2,0xA080E2,0xA180E2,
        0xAC82E2,0xB080E2,0x89D0,0xB980E2,0x8AD0,0x8CD0,0x8BD0,0x8FD0,    
        0x92D1,0x9880E2,0x9980E2,0x9C80E2,0x9D80E2,0xA280E2,0x9380E2,0x9480E2,
        0,0xA284E2,0x99D1,0xBA80E2,0x9AD1,0x9CD1,0x9BD1,0x9FD1,               
        0xA0C2,0x8ED0,0x9ED1,0x88D0,0xA4C2,0x90D2,0xA6C2,0xA7C2,              
        0x81D0,0xA9C2,0x84D0,0xABC2,0xACC2,0xADC2,0xAEC2,0x87D0,              
        0xB0C2,0xB1C2,0x86D0,0x96D1,0x91D2,0xB5C2,0xB6C2,0xB7C2,              
        0x91D1,0x9684E2,0x94D1,0xBBC2,0x98D1,0x85D0,0x95D1,0x97D1,            
        0x90D0,0x91D0,0x92D0,0x93D0,0x94D0,0x95D0,0x96D0,0x97D0,
        0x98D0,0x99D0,0x9AD0,0x9BD0,0x9CD0,0x9DD0,0x9ED0,0x9FD0,
        0xA0D0,0xA1D0,0xA2D0,0xA3D0,0xA4D0,0xA5D0,0xA6D0,0xA7D0,
        0xA8D0,0xA9D0,0xAAD0,0xABD0,0xACD0,0xADD0,0xAED0,0xAFD0,
        0xB0D0,0xB1D0,0xB2D0,0xB3D0,0xB4D0,0xB5D0,0xB6D0,0xB7D0,
        0xB8D0,0xB9D0,0xBAD0,0xBBD0,0xBCD0,0xBDD0,0xBED0,0xBFD0,
        0x80D1,0x81D1,0x82D1,0x83D1,0x84D1,0x85D1,0x86D1,0x87D1,
        0x88D1,0x89D1,0x8AD1,0x8BD1,0x8CD1,0x8DD1,0x8ED1,0x8FD1
    };
    while (*in)
        if (*in & 0x80) {
            int v = table[(int)(0x7f & *in++)];
            if (!v)
                continue;
            *out++ = (char)v;
            *out++ = (char)(v >> 8);
            if (v >>= 16)
                *out++ = (char)v;
        }
        else
            *out++ = *in++;
    *out = 0;
}

______________

при -О2:
6.25
5.46
-12

при -О3:
6.05
5.00
-17

при -О3 + предсказания переходов:
6.02
4.79
-20

^_^'

arsi ★★★★★
()
Ответ на: комментарий от arsi

Угу, и чем шустрее камень, тем сильнее моя сливает.

summatus ★
()
Ответ на: комментарий от summatus

> for(; *str; ++i ) ?
> Так будет медленнее.

Так мож и медленнее. cnt, i и j убери совсем, тогда будет быстрее. strlen тоже не нужен.

zzf
()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.
Development