自学教程：C++ wcwidth函数代码示例

std::wstring Scroller(const std::wstring &str, size_t &pos, size_t width){    std::wstring s(str);    if (!Config.header_text_scrolling)        return s;    std::wstring result;    size_t len = wideLength(s);    if (len > width)    {        s += L" ** ";        len = 0;        auto b = s.begin(), e = s.end();        for (auto it = b+pos; it < e && len < width; ++it)        {            if ((len += wcwidth(*it)) > width)                break;            result += *it;        }        if (++pos >= s.length())            pos = 0;        for (; len < width; ++b)        {            if ((len += wcwidth(*b)) > width)                break;            result += *b;        }    }    else        result = s;    return result;}

/* This function is equivalent to wcwidth() for multibyte characters. */int mbwidth(const char *c){    assert(c != NULL);#ifdef ENABLE_UTF8    if (use_utf8) {	wchar_t wc;	int width;	if (mbtowc(&wc, c, MB_CUR_MAX) < 0) {	    mbtowc_reset();	    wc = bad_wchar;	}	width = wcwidth(wc);	if (width == -1) {	    wc = bad_wchar;	    width = wcwidth(wc);	}	return width;    } else#endif	return 1;}

static voidcmd_ctrl_h(key_info_t key_info, keys_info_t *keys_info){	input_stat.history_search = HIST_NONE;	stop_completion();	if(input_stat.index == 0 && input_stat.len == 0 && sub_mode != PROMPT_SUBMODE)	{		cmd_ctrl_c(key_info, keys_info);		return;	}	if(input_stat.index == 0)		return;	if(input_stat.index == input_stat.len)	{		input_stat.index--;		input_stat.len--;		input_stat.curs_pos -= wcwidth(input_stat.line[input_stat.index]);		input_stat.line[input_stat.index] = L'/0';	}	else	{		input_stat.index--;		input_stat.len--;		input_stat.curs_pos -= wcwidth(input_stat.line[input_stat.index]);		wcsdel(input_stat.line, input_stat.index + 1, 1);	}	update_cmdline_text();}

std::wstring wideShorten(const std::wstring &ws, size_t max_length){	std::wstring result;	if (wideLength(ws) > max_length)	{		const size_t half_max = max_length/2 - 1;		size_t len = 0;		// get beginning of string		for (auto it = ws.begin(); it != ws.end(); ++it)		{			len += wcwidth(*it);			if (len > half_max)				break;			result += *it;		}		len = 0;		std::wstring end;		// get end of string in reverse order		for (auto it = ws.rbegin(); it != ws.rend(); ++it)		{			len += wcwidth(*it);			if (len > half_max)				break;			end += *it;		}		// apply end of string to its beginning		result += L"..";		result.append(end.rbegin(), end.rend());	}	else		result = ws;	return result;}

std::basic_string<my_char_t> Scroller(const std::basic_string<my_char_t> &str, size_t &pos, size_t width){	std::basic_string<my_char_t> s(str);	if (!Config.header_text_scrolling)		return s;	std::basic_string<my_char_t> result;	size_t len = Window::Length(s);		if (len > width)	{		s += U(" ** ");		len = 0;		std::basic_string<my_char_t>::const_iterator b = s.begin(), e = s.end();		for (std::basic_string<my_char_t>::const_iterator it = b+pos; it < e && len < width; ++it)		{			if ((len += wcwidth(*it)) > width)				break;			result += *it;		}		if (++pos >= s.length())			pos = 0;		for (; len < width; ++b)		{			if ((len += wcwidth(*b)) > width)				break;			result += *b;		}	}	else		result = s;	return result;}

void wbkgrndset(WINDOW *win, const cchar_t *wch){	attr_t battr;	nschar_t *np, *tnp;	unsigned int i;	/* ignore multi-column characters */	if ( !wch->elements || wcwidth( wch->vals[ 0 ]) > 1 )		return;	/* Background character. */	tnp = np = win->bnsp;	if ( wcwidth( wch->vals[ 0 ]))		win->bch = wch->vals[ 0 ];	else {		if ( !np ) {			np = (nschar_t *)malloc(sizeof(nschar_t));			if (!np)				return;			np->next = NULL;			win->bnsp = np;		}		np->ch = wch->vals[ 0 ];		tnp = np;		np = np->next;	}	/* add non-spacing characters */	if ( wch->elements > 1 ) {		for ( i = 1; i < wch->elements; i++ ) {			if ( !np ) {				np = (nschar_t *)malloc(sizeof(nschar_t));				if (!np)					return;				np->next = NULL;				if ( tnp )					tnp->next = np;				else					win->bnsp = np;			}			np->ch = wch->vals[ i ];			tnp = np;			np = np->next;		}	}	/* clear the old non-spacing characters */	while ( np ) {		tnp = np->next;		free( np );		np = tnp;	}	/* Background attributes (check colour). */	battr = wch->attributes & WA_ATTRIBUTES;	if (__using_color && !( battr & __COLOR))		battr |= __default_color;	win->battr = battr;	SET_BGWCOL((*win), 1);}

/* output a string, but wrap words properly with a specified indentation */void indentprint(const char *str, unsigned short indent, unsigned short cols){	wchar_t *wcstr;	const wchar_t *p;	size_t len, cidx;	if(!str) {		return;	}	/* if we're not a tty, or our tty is not wide enough that wrapping even makes	 * sense, print without indenting */	if(cols == 0 || indent > cols) {		fputs(str, stdout);		return;	}	len = strlen(str) + 1;	wcstr = calloc(len, sizeof(wchar_t));	len = mbstowcs(wcstr, str, len);	p = wcstr;	cidx = indent;	if(!p || !len) {		return;	}	while(*p) {		if(*p == L' ') {			const wchar_t *q, *next;			p++;			if(p == NULL || *p == L' ') continue;			next = wcschr(p, L' ');			if(next == NULL) {				next = p + wcslen(p);			}			/* len captures # cols */			len = 0;			q = p;			while(q < next) {				len += wcwidth(*q++);			}			if((len + 1) > (cols - cidx)) {				/* wrap to a newline and reindent */				printf("/n%-*s", (int)indent, "");				cidx = indent;			} else {				printf(" ");				cidx++;			}			continue;		}		printf("%lc", (wint_t)*p);		cidx += wcwidth(*p);		p++;	}	free(wcstr);}

void writeCyclicBuffer(const NC::WBuffer &buf, NC::Window &w, size_t &start_pos,                       size_t width, const std::wstring &separator){    const auto &s = buf.str();    size_t len = wideLength(s);    if (len > width)    {        len = 0;        const auto &ps = buf.properties();        auto p = ps.begin();        // load attributes from before starting pos        for (; p != ps.end() && p->position() < start_pos; ++p)            w << *p;        auto write_buffer = [&](size_t start) {            for (size_t i = start; i < s.length() && len < width; ++i)            {                for (; p != ps.end() && p->position() == i; ++p)                    w << *p;                len += wcwidth(s[i]);                if (len > width)                    break;                w << s[i];            }            for (; p != ps.end(); ++p)                w << *p;            p = ps.begin();        };        write_buffer(start_pos);        size_t i = 0;        if (start_pos > s.length())            i = start_pos - s.length();        for (; i < separator.length() && len < width; ++i)        {            len += wcwidth(separator[i]);            if (len > width)                break;            w << separator[i];        }        write_buffer(0);        ++start_pos;        if (start_pos >= s.length() + separator.length())            start_pos = 0;    }    else        w << buf;}

static unsigned int compute_len_from_width(const wchar_t *p, unsigned int width){	unsigned int len = 0;	unsigned int end_loop = 0;	while (p && *p && !end_loop) {		if (wcwidth(*p) > width) {			end_loop = 1;		} else {			width -= wcwidth(*p);			p++;			len++;		}	}	return len;}

int xwaddnstr (WINDOW *win, const char *str, const int n){	int res, width, inv_char;	wchar_t *ucs;	char *mstr, *lstr;	size_t size, num_chars;	assert (n > 0);	assert (str != NULL);	mstr = iconv_str (iconv_desc, str);	size = xmbstowcs (NULL, mstr, -1, NULL) + 1;	ucs = (wchar_t *)xmalloc (sizeof(wchar_t) * size);	xmbstowcs (ucs, mstr, size, &inv_char);	width = wcswidth (ucs, WIDTH_MAX);	if (width == -1) {		size_t clidx;		for (clidx = 0; clidx < size - 1; clidx++) {			if (wcwidth (ucs[clidx]) == -1)				ucs[clidx] = L'?';		}		width = wcswidth (ucs, WIDTH_MAX);		inv_char = 1;	}	if (width > n) {		while (width > n)			width -= wcwidth (ucs[--size]);		ucs[size] = L'/0';	}	num_chars = wcstombs (NULL, ucs, 0);	lstr = (char *)xmalloc (num_chars + 1);	if (inv_char)		wcstombs (lstr, ucs, num_chars + 1);	else		snprintf (lstr, num_chars + 1, "%s", mstr);	res = waddstr (win, lstr);	free (ucs);	free (lstr);	free (mstr);	return res;}

/** * Validates data needed for text scrolling in widget * * @param __edit - edit for which validate scrolling information */static voidedit_validate_scrolling (w_edit_t *__edit){  if (!__edit)    {      return;    }  size_t scrolled = __edit->scrolled, i;  /* Relative position of caret */  size_t caret_pos_rel = __edit->caret_pos - scrolled + 1;  for (i = scrolled; i < __edit->caret_pos; ++i)    {      caret_pos_rel += wcwidth (__edit->text.data[i]) - 1;    }  /* Cursor is far too left */  if (__edit->caret_pos < __edit->scrolled)    {      __edit->scrolled = __edit->caret_pos;    }  else    {      /* Cursor is far too right */      if (caret_pos_rel >= __edit->position.width)        {          __edit->scrolled += caret_pos_rel - __edit->position.width;        }    }}

static void loadLanguageList(void) {    char * file = "/etc/lang-table";    FILE * f;    char line[256];    char name[256], key[256], font[256], code[256],        keyboard[256], timezone[256];    int lineNum = 0;    wcwidth(0);    f = fopen(file, "r");    if (!f) {        newtWinMessage(_("Error"), _("OK"), "cannot open %s: %m", file);        return;    }    while (fgets(line, sizeof(line), f)) {        lineNum++;        languages = realloc(languages, sizeof(*languages) * (numLanguages + 1));        if (sscanf(line, "%[^/t]/t%[^/t]/t%[^/t]/t%[^/t]/t%[^/t]/t%[^/t]/n",                   name, key, font, code, keyboard, timezone) != 6) {            printf("bad line %d in lang-table", lineNum);            logMessage(WARNING, "bad line %d in lang-table", lineNum);        } else {            languages[numLanguages].lang = strdup(name);            languages[numLanguages].key = strdup(key);            languages[numLanguages].font = strdup(font);            languages[numLanguages].lc_all = strdup(code);            languages[numLanguages++].keyboard = strdup(keyboard);        }    }    fclose(f);}

/* Return a malloc()ed string containing the tail of 'str' up to a * maximum of 'len' characters (in columns occupied on the screen). */char *xstrtail (const char *str, const int len){	wchar_t *ucs;	wchar_t *ucs_tail;	size_t size;	int width;	char *tail;	assert (str != NULL);	assert (len > 0);	size = xmbstowcs(NULL, str, -1, NULL) + 1;	ucs = (wchar_t *)xmalloc (sizeof(wchar_t) * size);	xmbstowcs (ucs, str, size, NULL);	ucs_tail = ucs;	width = wcswidth (ucs, WIDTH_MAX);	assert (width >= 0);	while (width > len)		width -= wcwidth (*ucs_tail++);	size = wcstombs (NULL, ucs_tail, 0) + 1;	tail = (char *)xmalloc (size);	wcstombs (tail, ucs_tail, size);	free (ucs);	return tail;}

static int putxy(WINDOW *win, int width, int *i, int *y, int *x, char *str){    if ((unsigned char) str[0] > 0x7F) {        wchar_t dest[2];        int bytes = mbtowc(dest, &str[0], 3) - 1;        if (bytes >= 0) {            /* To deal with non-latin characters that can take               up more than one character's alotted width,                with offset x by wcwidth(character) rather than 1 */            /* Took me forever to find that function, thanks               Andreas (newsbeuter) for that one. */            int rwidth = wcwidth(dest[0]);            if (rwidth < 0)                rwidth = 1;            if (rwidth > (width - *x))                return 1;            dest[1] = 0;            mvwaddwstr(win, *y, *x, dest);            *x += rwidth;            *i += bytes;        }    } else        mvwaddch(win, *y, (*x)++, str[0]);    return 0;}

static voidputline(FILE *file, char *start, int num){	char	*cp, *end;	int	i, len, d_col;	wchar_t	wc;	cp = start;	end = cp + num;	while (cp < end) {		if (isascii(*cp)) {			(void) putc(*cp++, file);			continue;		}		if ((len = end - cp) > MB_LEN_MAX)			len = MB_LEN_MAX;		if ((len = mbtowc(&wc, cp, len)) <= 0) {			(void) putc(*cp++, file);			continue;		}		if ((d_col = wcwidth(wc)) <= 0)			d_col = len;		if ((cp + d_col) > end)			return;		for (i = 0; i < len; i++)			(void) putc(*cp++, file);	}}

/** * mutt_strwidth - Measure a string's width in screen cells * @param s String to be measured * @retval num Screen cells string would use */int mutt_strwidth(const char *s){  wchar_t wc;  int w;  size_t k, n;  mbstate_t mbstate;  if (!s)    return 0;  n = mutt_str_strlen(s);  memset(&mbstate, 0, sizeof(mbstate));  for (w = 0; n && (k = mbrtowc(&wc, s, n, &mbstate)); s += k, n -= k)  {    if (*s == MUTT_SPECIAL_INDEX)    {      s += 2; /* skip the index coloring sequence */      k = 0;      continue;    }    if ((k == (size_t)(-1)) || (k == (size_t)(-2)))    {      if (k == (size_t)(-1))        memset(&mbstate, 0, sizeof(mbstate));      k = (k == (size_t)(-1)) ? 1 : n;      wc = ReplacementChar;    }    if (!IsWPrint(wc))      wc = '?';    w += wcwidth(wc);  }  return w;}

VALUE tui_wcwidth(VALUE self, VALUE glyph) {	long ig;	int res; 	ig = FIX2LONG(glyph);	res = wcwidth(ig);	return INT2FIX(res);}

/* re_putc(): *	Draw the character given */libedit_private voidre_putc(EditLine *el, wint_t c, int shift){	coord_t *cur = &el->el_refresh.r_cursor;	int i, w = wcwidth(c);	int sizeh = el->el_terminal.t_size.h;	ELRE_DEBUG(1, (__F, "printing %5x '%lc'/r/n", c, c));	if (w == -1)		w = 0;	while (shift && (cur->h + w > sizeh))	    re_putc(el, ' ', 1);	el->el_vdisplay[cur->v][cur->h] = c;	/* assumes !shift is only used for single-column chars */	i = w;	while (--i > 0)		el->el_vdisplay[cur->v][cur->h + i] = MB_FILL_CHAR;	if (!shift)		return;	cur->h += w;	/* advance to next place */	if (cur->h >= sizeh) {		/* assure end of line */		el->el_vdisplay[cur->v][sizeh] = '/0';		re_nextline(el);	}}

intmbsprint(const char *mbs, int print){	wchar_t	  wc;	int	  len;  /* length in bytes of UTF-8 encoded string */	int	  width;  /* display width of a single Unicode char */	int	  total_width;  /* display width of the whole string */	for (total_width = 0; *mbs != '/0'; mbs += len) {		if ((len = mbtowc(&wc, mbs, MB_CUR_MAX)) == -1) {			(void)mbtowc(NULL, NULL, MB_CUR_MAX);			if (print)				putchar(f_nonprint ? '?' : *mbs);			total_width++;			len = 1;		} else if ((width = wcwidth(wc)) == -1) {			if (print) {				if (f_nonprint)					putchar('?');				else					fwrite(mbs, 1, len, stdout);			}			total_width++;		} else {			if (print)				fwrite(mbs, 1, len, stdout);			total_width += width;		}	}	return total_width;}

static int theme_strlen(char *message, char end){    int len = 0;    int i = 0;    while ((message[i] != end) && (message[i] != 0)) {        if (message[i] == '%') {            i++;        } else if (message[i] == '//') {            i++;            len++;        } else if ((unsigned char) message[i] > 0x7f) {            wchar_t dest[2];            int bytes = mbtowc(dest, &message[i], 3) - 1;            if (bytes >= 0) {                int rwidth = wcwidth(dest[0]);                if(rwidth < 0)                    rwidth = 1;                i += bytes;                len += rwidth;            } else {                i++;                len += 1;            }        } else if (message[i] != '/n')            len++;        i++;    }    return len;}

/* * Update the current column position for a character. */static intnewpos(int col, wint_t ch){	char buf[MB_LEN_MAX];	size_t len;	int w;	if (bflag) {		len = wcrtomb(buf, ch, NULL);		col += len;	} else		switch (ch) {		case '/b':			if (col > 0)				--col;			break;		case '/r':			col = 0;			break;		case '/t':			col = (col + 8) & ~7;			break;		default:			if ((w = wcwidth(ch)) > 0)				col += w;			break;		}	return (col);}

intmain(void){	int	wc;	int	i, n;	if (setlocale(LC_CTYPE, "en_US.utf8") == NULL)		if (setlocale(LC_CTYPE, "en_US.UTF-8") == NULL)			return 1;	for (wc = 0; wc <= 0xffff; wc++) {		if ((wc&017) == 0)			printf("U+%04X  ", wc);		if (wc < 040)			n = printf("%s", ctl[wc]);		else if (wc == 0177)			n = printf("del");		else if (wc >= 0200 && wc < 0240)			n = printf("CTL");		else if (iswprint(wc)) {			if ((n = wcwidth(wc)) == 0)				n = 1;			printf("%lc", wc);		} else			n = 0;		for (i = n; i < 4; i++)			putchar(' ');		if ((wc+1&017) == 0)			putchar('/n');	}	return 0;}

/** * mutt_paddstr - Display a string on screen, padded if necessary * @param n Final width of field * @param s String to display */void mutt_paddstr(int n, const char *s){  wchar_t wc;  size_t k;  size_t len = mutt_str_strlen(s);  mbstate_t mbstate;  memset(&mbstate, 0, sizeof(mbstate));  for (; len && (k = mbrtowc(&wc, s, len, &mbstate)); s += k, len -= k)  {    if ((k == (size_t)(-1)) || (k == (size_t)(-2)))    {      if (k == (size_t)(-1))        memset(&mbstate, 0, sizeof(mbstate));      k = (k == (size_t)(-1)) ? 1 : len;      wc = ReplacementChar;    }    if (!IsWPrint(wc))      wc = '?';    const int w = wcwidth(wc);    if (w >= 0)    {      if (w > n)        break;      addnstr((char *) s, k);      n -= w;    }  }  while (n-- > 0)    addch(' ');}

/* Calculate display width of an UTF-8 string */int utf8_width(char *str){	int w = 0;	size_t nbytes = strlen(str);	mbstate_t mbstate;	memset(&mbstate, 0, sizeof(mbstate));	while (nbytes > 0)	{		/* Convert to unicode */		wchar_t ch;		size_t n = mbrtowc(&ch, str, nbytes, &mbstate);		if (n >= (size_t)(-2))		{			++w;			++str;			continue;		}		/* Should not happen if locale is correct */		if (n == 0)			break;		str += n;		nbytes -= n;		int cw = wcwidth(ch);		if (cw > 0)			w += cw;	}	return w;} /* End of 'utf8_width' function */

intprn_normal(const char *s){	mbstate_t mbs;	wchar_t wc;	int i, n;	size_t clen;	memset(&mbs, 0, sizeof(mbs));	n = 0;	while ((clen = mbrtowc(&wc, s, MB_LEN_MAX, &mbs)) != 0) {		if (clen == (size_t)-2) {			n += printf("%s", s);			break;		}		if (clen == (size_t)-1) {			memset(&mbs, 0, sizeof(mbs));			putchar((unsigned char)*s);			s++;			n++;			continue;		}		for (i = 0; i < (int)clen; i++)			putchar((unsigned char)s[i]);		s += clen;		if (iswprint(wc))			n += wcwidth(wc);	}	return (n);}

TSTLStrSize MBWidth(std::string str){    if (str.empty())        return 0;        TSTLStrSize ret = 0;    std::wstring utf16;    std::string::iterator end = utf8::find_invalid(str.begin(), str.end());    assert(end == str.end());        // HACK: Just append length of invalid part    if (end != str.end())        ret = std::distance(end, str.end());        utf8::utf8to16(str.begin(), end, std::back_inserter(utf16));    // As wcswidth returns -1 when it finds a non printable char, we just use    // wcwidth and assume a 0 width for those chars.    TSTLStrSize n = 0, length = utf16.length();    for (; n<length; n++)    {        int w = wcwidth(utf16[n]);        if (w > 0)            ret += static_cast<TSTLStrSize>(w);    }        return ret;}

/* * Insert the given character, updating the current location to simplify * inserting a string. */static int_nc_insert_wch(WINDOW *win, const cchar_t *wch){    int cells = wcwidth(CharOf(CHDEREF(wch)));    int cell;    if (cells <= 0)        cells = 1;    if (win->_curx <= win->_maxx) {        struct ldat *line = &(win->_line[win->_cury]);        NCURSES_CH_T *end = &(line->text[win->_curx]);        NCURSES_CH_T *temp1 = &(line->text[win->_maxx]);        NCURSES_CH_T *temp2 = temp1 - cells;        CHANGED_TO_EOL(line, win->_curx, win->_maxx);        while (temp1 > end)            *temp1-- = *temp2--;        *temp1 = _nc_render(win, *wch);        for (cell = 1; cell < cells; ++cell) {            SetWidecExt(temp1[cell], cell);        }        win->_curx++;    }    return OK;}

/* ARGSUSED */static size_tlocale_width(const struct termp *p, int c){	int		rc;	return((rc = wcwidth(c)) < 0 ? 0 : rc);}

_nc_insert_wch(WINDOW *win, const cchar_t *wch){    int cells = wcwidth(CharOf(CHDEREF(wch)));    int cell;    int code = OK;    if (cells < 0) {	code = winsch(win, (chtype) CharOf(CHDEREF(wch)));    } else {	if (cells == 0)	    cells = 1;	if (win->_curx <= win->_maxx) {	    struct ldat *line = &(win->_line[win->_cury]);	    NCURSES_CH_T *end = &(line->text[win->_curx]);	    NCURSES_CH_T *temp1 = &(line->text[win->_maxx]);	    NCURSES_CH_T *temp2 = temp1 - cells;	    CHANGED_TO_EOL(line, win->_curx, win->_maxx);	    while (temp1 > end)		*temp1-- = *temp2--;	    *temp1 = _nc_render(win, *wch);	    for (cell = 1; cell < cells; ++cell) {		SetWidecExt(temp1[cell], cell);	    }	    win->_curx = (NCURSES_SIZE_T) (win->_curx + cells);	}    }    return code;}