C++ string::capacity方法代码示例

int FileToString( const char* filename, std::string& out_contents )
{
	FILE *fp;
	fp = fopen(filename,"r");
	if (!fp) 
	{
		printf("Unable to open file '%s' for read into string (%s, %d)\n",filename, __FILE__, __LINE__);
		return 1;
	}
	const size_t capacity_increment = 512;
	try
	{
		out_contents.clear();
		out_contents.reserve(capacity_increment);
		for (int this_char = fgetc(fp); this_char != EOF; this_char = fgetc(fp))
		{
			//embiggenate the buffer, if needed
			if(out_contents.capacity() == out_contents.size())
			{
				out_contents.reserve(out_contents.capacity() + capacity_increment);
			}
			out_contents.push_back(static_cast<char>(this_char));
		}
	}
	catch (const std::exception& e)
	{
		printf("caught exception '%s' while reading file '%s' into string (%s, %d)\n",e.what(), filename, __FILE__, __LINE__);
		return 1;
	}
	return 0;
}

void load_file(std::string& s, std::istream& is)
{
   s.erase();
   if(is.bad()) return;
   s.reserve(static_cast<std::string::size_type>(is.rdbuf()->in_avail()));
   char c;
   while(is.get(c))
   {
      if(s.capacity() == s.size())
         s.reserve(s.capacity() * 3);
      s.append(1, c);
   }
}

void Dow::Handle::GetClassName (std::string & name) const
{
	// Revisit: there is better API RealGetWindowClass, but it is supported
	// only in Win98, NT 4.0 with SP3 and Win2000
	unsigned lenAvailable = 128;
	unsigned lenWritten = 0;
	do
	{
		name.reserve (lenAvailable); // could reserve more
		lenWritten = ::GetClassName (H (), writable_string (name), name.capacity ());
		lenAvailable = 2 * name.capacity ();
	} while (lenWritten + 1 == name.capacity ());
}

void load_file1(std::string& s, std::istream& is)
{
   s.erase();   //删除字符串
   	//bad() 如果出现错误则返回true 
   if(is.bad()) return;
   s.reserve(is.rdbuf()->in_avail());  //reserve 预留空间 
   char c;
   while(is.get(c))
   { //capacity 在不重新分配内存的情况下，字符串可能的大小  size 得到字符串的大小 
      if(s.capacity() == s.size())
         s.reserve(s.capacity() * 3);
      s.append(1, c);  //append 追加字符 
   }
}

// original source: 
// https://github.com/facebook/folly/blob/master/folly/String.cpp
//
void vStringFormat(std::string& output, const char* format, va_list args)
{
	va_list tmpargs;

	va_copy(tmpargs,args);
	int characters_used = vsnprintf(nullptr, 0, format, tmpargs);
	va_end(tmpargs);

	if (characters_used < 0) {
		// Looks like we have an invalid format string.
		// error out.
		std::string errorMessage("Invalid format string; snprintf returned negative with format string: ");
		errorMessage.append(format);
		
		throw std::runtime_error(errorMessage);
	}
	else if ((unsigned int)characters_used > output.capacity()) {
		output.resize(characters_used+1);
		va_copy(tmpargs,args);
		characters_used = vsnprintf(&output[0], output.capacity(), format, tmpargs);
		va_end(tmpargs);

		if (characters_used < 0) {
			// We shouldn't have a format error by this point, but I can't imagine what error we
			// could have by this point. Still, error out and report it.
			std::string errorMessage("Invalid format string or unknown vsnprintf error; vsnprintf returned negative with format string: ");
			errorMessage.append(format);
		
			throw std::runtime_error(errorMessage);
		}
	} 
	else {
		output.resize(characters_used + 1);

		va_copy(tmpargs,args);
		characters_used = vsnprintf(&output[0], output.capacity(), format, tmpargs);
		va_end(tmpargs);

		if (characters_used < 0) {
			// We shouldn't have a format error by this point, but I can't imagine what error we
			// could have by this point. still error out and report it.
			std::string errorMessage("Invalid format string or unknown vsnprintf error; vsnprintf returned negative with format string: ");
			errorMessage.append(format);
		
			throw std::runtime_error(errorMessage);
		}
		
	}
}

std::string escape(const std::string str, bool intag = true)
{
    std::string ret = str;

    ret.reserve(str.capacity() * 2);

    for (const char c : str) {
        if (c == '<') {
            ret += "&lt;";
        }
        else if (c == '>') {
            ret += "&gt;";
        }
        else if (c == '&') {
            ret += "&amp;";
        }
        else if (intag) {
            if (c == '\'') {
                ret += "&abuff;";
            }
            else if (c == '\"') {
                ret += "&quot;";
            }
            else {
                ret += c;
            }
        }
        else {
            ret += c;
        }
    }
    return ret;
}

std::string EscapeForHTML(const std::string& str)
{
    typedef std::map<char, std::string> EscapeMap;
    static const EscapeMap kHtmlEscapeMap {
        { '<', "&lt;" },
        { '>', "&gt;" },
        { '&', "&amp;" },
        { '"', "&quot;" },
        { '\'', "&#39;" },
    };

    std::string strResult;
    strResult.reserve(str.capacity());
    for (auto v : str)
    {
        auto i = kHtmlEscapeMap.find(v);
        if (i == kHtmlEscapeMap.end())
        {
            strResult.push_back(v);
            continue;
        }
        strResult.append(i->second);
    }
    return strResult;
}

void encoder::encode(std::string& s) {
    s.resize(std::max(s.capacity(), size_t(1))); // Use full capacity, ensure not empty
	size_t size = s.size();
    if (!encode(&s[0], size)) {
        s.resize(size);
        encode(&s[0], size);
    }
}

void load_file(std::string& s, std::istream& is)
{
   s.erase();
   //
   // attempt to grow string buffer to match file size,
   // this doesn't always work...
   s.reserve(is.rdbuf()->in_avail());
   char c;
   while(is.get(c))
   {
      // use logarithmic growth stategy, in case
      // in_avail (above) returned zero:
      if(s.capacity() == s.size())
         s.reserve(s.capacity() * 3);
      s.append(1, c);
   }
}

 void write(std::string& s, const char* from, const char* to) {
     assert(from <= to);
     const size_t addCount = to - from;
     if ( s.capacity() <= s.size() + addCount )
     {
         s.reserve( 2 * s.size() + addCount );
     }
     s.append(from, to);
 }

void TCPSocket::Getline(std::string& buffer, bool stripCRLF)
{
  buffer.clear();
  buffer.reserve(defaultBufferSize);
  
  char ch;
  do
  {
    ch = GetcharBuffered();
    if (!stripCRLF || (ch != '\r' && ch != '\n'))
    {
      buffer += ch;
      if (buffer.length() == buffer.capacity())
        buffer.reserve((buffer.capacity() / defaultBufferSize) + 1);
    }
  }
  while (ch != '\n');
}

static std::string ConvertToLower(std::string const& inString)
{
	std::string outString;
	outString.reserve(inString.capacity());
	for (uint32_t i=0; i<inString.length(); i++) {
		outString+=tolower(inString[i]);
	}
	return outString;
}

void func (std::string a, std::wstring b)
{
	printf ("%s\n", a.c_str());
	printf ("%d\n", a.size());
	printf ("%d\n", a.capacity());

	wprintf (L"%s\n", b.c_str());
	printf ("%d\n", b.size());
	printf ("%d\n", b.capacity());
};

 bool ShowAndGetNewPassword(
       std::string&            strNewPassword,
       unsigned int            autoCloseMs)
 {
   strNewPassword.resize(1024);
   unsigned int size = (unsigned int)strNewPassword.capacity();
   bool ret = g_interProcess.m_Callbacks->GUI.Dialogs.Keyboard.ShowAndGetNewPassword(strNewPassword[0], size, autoCloseMs);
   strNewPassword.resize(size);
   strNewPassword.shrink_to_fit();
   return ret;
 }

uint32_t
MemoryConsumption::getStringMemoryUsage(const std::string& s, uint32_t& uniqueCount) {
    ++_totalStringCount;
    const char* internalString = s.c_str();
    if (_seenStrings->find(internalString) != _seenStrings->end()) {
        return 0;
    }
    ++uniqueCount;
    _seenStrings->insert(internalString);
    return s.capacity();
}