Format a number with thousand separator characters in Rust

The following code function snippet is an example of how to format a number (already in String/&str form) with thousand separator characters in Rust:

pub fn thousand_separate_string_number(string_val: &str) -> String {
    let mut s = String::new();
    let mut local_copy = string_val.to_string();
    
    let decimal_pos = local_copy.rfind('.');
    if let Some(pos) = decimal_pos {
        // deal with any decimal place digit and following digits first
        s.push_str(&string_val[pos..]);
        local_copy = string_val[..pos].to_string();
    }
    
    let chrs = local_copy.chars().rev().enumerate();
    for (idx, val) in chrs {
        if idx != 0 && idx % 3 == 0 {
            s.insert(0, ',');
        }
        s.insert(0, val);
    }
    s
}

Get length of longest String in a Vec in Rust

The following code snippet is an example of how to find out the length of the longest String in a Vec using Rust:

let string_vec = vec!["One", "Two", "Three", "Twenty"];
let max_string_length = string_vec.iter().map(|t| t.len()).max().unwrap();
eprintln!("Max string length: {}", max_string_length);

Format a number with thousand separator characters in C++

The following code function snippet is an example of how format a number (already in std::string form) with thousand separator characters in C++:

Note: it doesn’t currently support numbers with decimal places, only integer-formatted numbers.

std::string formatNumberThousandsSeparator(const std::string& value)
{
	std::string final;
	int i = value.size() - 1;
	unsigned int count = 0;
	for (; i >= 0; i--)
	{
		final += value[i];

		if (count++ == 2 && i != 0)
		{
			final += ",";
			count = 0;
		}
	}

	std::reverse(final.begin(), final.end());

	return final;
}

Stripping whitespace characters from an std::string in C++

C++ unfortunately does not have very many built-in convenient string-handling methods, although there are libraries like boost and pystring that can be used to obtain functionality that is found in other more modern programming languages.

However, sometimes using external dependencies is not possible or wanted for a variety of reasons.

The following code function snippet is an example of how to strip whitespace (space) characters from the start and end of an std::string in C++, in-place modifying the std::string passed in:

void stripWhitespace(std::string& str)
{
	if (str.empty())
		return;

	// use space and tab chars for whitespace...
	static const char* kWhitespaceChars = " \t";

	size_t firstNonWhitespacePos = str.find_first_not_of(kWhitespaceChars, 0);
	if (firstNonWhitespacePos == std::string::npos)
	{
		// we didn't find a non-whitespace char, so set string to empty
		str = "";
		return;
	}

	size_t lastNonWhitespacePos = str.find_last_not_of(kWhitespaceChars);
	if (lastNonWhitespacePos == std::string::npos ||
		lastNonWhitespacePos < firstNonWhitespacePos)
	{
		// this shouldn't really be possible, but something's gone wrong...
		return;
	}

	// extract the string from the non-whitespace start/end chars
	str = str.substr(firstNonWhitespacePos, lastNonWhitespacePos - firstNonWhitespacePos + 1);
}

Splitting an std::string in C++

C++ unfortunately does not have very many built-in convenient string-handling methods, although there are libraries like boost and pystring that can be used to obtain functionality that is found in other more modern programming languages.

However, sometimes using external dependencies is not possible or wanted for a variety of reasons.

The following code function snippet is an example of how to split an std::string into an std::vector of strings based on a separator string in C++:

void splitString(const std::string& str, std::vector<std::string>& stringTokens, const std::string& sep)
{
	size_t lastPos = str.find_first_not_of(sep, 0);
	size_t pos = str.find_first_of(sep, lastPos);

	while (lastPos != std::string::npos || pos != std::string::npos)
	{
		stringTokens.push_back(str.substr(lastPos, pos - lastPos));
		lastPos = str.find_first_not_of(sep, pos);
		pos = str.find_first_of(sep, lastPos);
	}
}