c32rtomb() function in C/C++

The c32rtomb() method converts a wide character of type char32_t to a multibyte character and provides the number of bytes possessed in the s (which includes any shift operations). If s is not a null pointer, the c32rtomb() function calculates the number of bytes required to represent a multibyte character that's equivalent to the wide character given by c32 (which includes any shift sequences). It maintains the multibyte character representation in the form of an array whose first element is being pointed to by s. A maximum of MB_CUR_MAX bytes are saved. If the c32 is a null-wide character, a null byte is saved, followed by any shift sequence required to restore the original shift state; the state that results described is the initial conversion state.

The c32rtomb() method is equal to the call c32rtomb(buf, L'0', ps) if s is null. If ps is null, c32rtomb() uses its internal object to monitor the shift status. If not, *ps has to be an appropriate mbstate_t object. By assigning 0 to a mbstate_t object *ps or using c32rtomb(NULL, L'0', ps), it may be initialized to the starting state.

Syntax:

It has the following syntax:

Parameters:

The function requires three arguments, which are listed below:

s: It indicates the string in which the multibyte character will be placed.

C16 denotes the 32-bit character to be converted.

The multibyte string's interpretation is done using an mbstate_t object, which is being directed to by the value p.

Return Value:

Return Estimate: Both of the following values are returned by the function:

The number of bytes sent to the character array that s referred to is returned by the function at program completion.

If it is unsuccessful, EILSEQ is saved in err no., and -1 is returned.

Example:

Filename: C32rtomb.cpp

// Program to implement the c32rtomb() function in c++
#include <iostream> 
#include <uchar.h> 
#include <wchar.h> 
using namespace std; 
// main 
int main() 
{ 
	const char32_t strs[] = U"Progarmming"; 
	char st[50]; 
	mbstate_t pg{}; 
	size_t len; 
	int j = 0; 

	while (strs[j]) { 
		// the function initialization
		len = c32rtomb(st, strs[j], &pg); 
		if ((len== 0) || (len > 50)) 
			break; 

		for (int i = 0; i < len; ++i) 
			cout << st[i]; 
		++j; 
	} 

	return 0; 
} 

Output:

Programming

Example 2:

Filename: C32rtomb_failure.cpp

// Program to implement the c32rtomb() function in c++
#include <iostream> 
#include <uchar.h> 
#include <wchar.h> 
using namespace std; 
// main 
int main() 
{ 
	const char32_t strs[] = U""; 
	char st[50]; 
	mbstate_t pg{}; 
	size_t len; 
	int j = 0; 

	while (strs[j]) { 
		// the function initialization
		len = c32rtomb(st, strs[j], &pg); 
		if ((len== 0) || (len > 50)) 
			break; 

		for (int i = 0; i < len; ++i) 
			cout << st[i]; 
		++j; 
	} 

	return 0; 
} 

Note: It doesn't produce any output because it was under the failure condition.

Advantages of c32rtomb() function:

There are several advantages of the c32rtomb() function. Some main advantages of the c32rtomb() function are as follows:

1. Location-Dependent Character Encoding:

Various character encodings are used in various locations. If the current locale specifies rules, this method can convert wide characters to multibyte characters.

2. Managing Multibyte Characters in File System Output:

With c32rtomb(), wide characters in C/C++ may be transformed into a multibyte representation prior to writing to a file when performing file I/O operations and handling wide characters.

3. Both localization and internationalization:

This feature is essential for programs that manage translation and internationalization as it allows wide characters to be converted to multibyte sequences that are compatible with the locale, allowing characters unique to a particular language or location to be correctly represented.

4. Preserving compatibility and portability:

The c32rtomb() facilitates the conversion of wide characters into a format that complies with the locale of each system, which is helpful for applications that must function on several platforms with different encoding standards. It guarantees consistent performance in a variety of settings.

5. Error management and Robustness:

Error management is an important consideration when using c32rtomb(). To address cases when the wide-character cannot be represented in the currently used encoding, developers must look for conversion issues, which are indicated by the function returning (size_t)-1. When such problems emerge, easy degradation or other solutions are ensured through robust error handling.

Next TopicCartesian Tree Sorting in C++

← prev next →