utx::wstr

utx::wstr_new

utx::wstr_new is an alias template or a "derived from" class, used to create a string by new, by guaranteeing always auto-fill L'\0' for empty space.

utx::str_new_class

It is alias template of or derived from utx::str_new_class, for support specific character type.

The preferred choice is to use alias template, but for compatible, "derived from" is selected.

Rules:

It guarantees a string space of at least 1 size length is always allocated by new ;
If the string size is 0, 1 size space will be allocated, by initializing it with '\0';
If the string size is N (N > 0), N+1 size space will be allocated, The last space is always initialized with '\0' .
If the real data length is M (M>=0), and the allocated space is N+1 (M<=N, N>=0), then the M size space will be initialized with real data, and the rest space will be all initialized with '\0' ;
If the size from template param is N (N > 0), but the string used to initialize is empty or is "", then N+1 size space will be allocated, and all space will be initialized with '\0' ;
If the size from template param is empty or is N (N==0), but the string used to initialize is not empty and not "", such as "string", then the allocated space is utx::str_size("string")+1, and space will be initialized with "string\0" ;
Any string created by it must be destroyed by delete [] str, it does not have deleter in the destructor, because the name utx::???str_new has a word new ;
As it is class, having all object-oriented features, it can be used for extra object-oriented style case, however it's not encouraged to use it for additional object-oriented cases, because:

It is designed for the following style usage case originally:

// Can be also applied to utx::wstr_new, ..., etc.
char * ptr = utx::str_new<12>{"Hell c++!"};	// 12+1
// The real content of created space is:
// "Hell c++!\0\0\0\0"
delete [] ptr;

// Can be also applied to utx::wstr_new, ..., etc.
// Both char * and const char * work, and size in template param can be auto-deduced.
const char * ptr2 = utx::str_new{"Hell c++!"};	// 9+1
delete [] ptr2;

c++ example

#include <utxcpp/core.hpp>

int main()
{
	// Allocate 17+1 size space, and init them with L'\0'
	// const wchar_t * works for return type.
	const wchar_t * s1 = utx::wstr_new<17>{};

	// Allocate utx::wstr_size(L"Hell c++!")+1 size space,
	// and init them with L"Hell c++!", the rest with L'\0'
	// wchar_t * works for return type too.
	wchar_t * s2 = utx::wstr_new{L"Hell c++!"};

	// Allocate 17+1 size space,
	// init first utx::wstr_size(L"Hell c++!") size space with L"Hell c++!",
	// and init the rest space with L'\0'.
	const wchar_t * s3 = utx::wstr_new<17>{L"Hell c++!"};

	// Allocate 4+1 size space,
	// init first 4 size space with L"Hell",
	// and init the rest space with L'\0'.
	const wchar_t * s4 = utx::wstr_new<4>{L"Hell c++!"};

	utx::wprint(s1, s2, s3, s4);

	// All of string created by utx::wstr_new must be destroyed by delete .

	delete [] s1;
	delete [] s2;
	delete [] s3;
	delete [] s4;
}

utx::wstr_new

utx::wstr_new

utx::str_new_class

Rules:

c++ example

See Also