utx::str

utx::str_new

utx::str_new is an alias template or a "derived from" class, used to create a string by new, by guaranteeing always auto-fill '\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 '\0'
	// const char * works for return type.
	const char * s1 = utx::str_new<17>{};

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

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

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

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

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

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

utx::str_new

utx::str_new

utx::str_new_class

Rules:

c++ example

See Also