Working with C-Style Strings

Safely Resizing C-Style Strings

How can I safely resize a C-style string without causing buffer overflow?

Abstract art representing computer programming

Safely resizing a C-style string is a bit tricky because C-style strings are essentially arrays of characters, and arrays in C++ have a fixed size once they're created. However, we can implement a safe resizing operation by allocating a new buffer and copying the contents. Here's a step-by-step approach:

  1. Allocate a new buffer with the desired size.
  2. Copy the contents of the old buffer to the new one.
  3. Null-terminate the new buffer.
  4. Delete the old buffer (if it was dynamically allocated).
  5. Update the pointer to point to the new buffer.

Here's an example implementation:

#include <iostream>
#include <cstring>
#include <algorithm>

// Function to safely resize a C-style string
char* resizeString(
  const char* oldStr, size_t newSize
) {
  size_t oldSize = std::strlen(oldStr);
  char* newStr = new char[newSize];

  // Copy old string contents, ensuring we
  // don't overflow
    newStr, oldStr, std::min(oldSize, newSize - 1)

  // Ensure null-termination
  newStr[std::min(oldSize, newSize - 1)] = '\0';

  return newStr;

int main() {
  const char* original = "Hello, World!";
  std::cout << "Original: " << original << '\n';

  // Resize to a larger buffer
  char* enlarged = resizeString(
      original, 30);  // Increase the buffer size
  strncat_s(enlarged, 30, " How are you?",
            30 - std::strlen(enlarged) - 1);
  std::cout << "Enlarged: " << enlarged << '\n';

  // Resize to a smaller buffer (truncation occurs)
  char* shortened = resizeString(original, 9);

  std::cout << "Shortened: " << shortened;

  // Clean up
  delete[] enlarged;
  delete[] shortened;
Original: Hello, World!
Enlarged: Hello, World! How are you?
Shortened: Hello, W

This approach ensures that we don't overflow our buffer, even when resizing to a smaller size. Note a few important points:

  1. We use std::strncpy() instead of std::strcpy() to avoid buffer overflows.
  2. We explicitly null-terminate the new string to ensure it's always valid.
  3. We're using dynamic allocation (new and delete[]), which means we need to manage memory manually.

To make this safer and more C++-like, we could use smart pointers:

#include <iostream>
#include <cstring>
#include <memory>
#include <algorithm>

std::unique_ptr<char[]> resizeString(
  const char* oldStr, size_t newSize
) {
  size_t oldSize{std::strlen(oldStr)};
  auto newStr{std::make_unique<char[]>(newSize)};

    oldStr + std::min(oldSize, newSize - 1),

  newStr[newSize - 1] = '\0';

  return newStr;

void safeConcat(
  std::unique_ptr<char[]>& dest,
  const char* src,
  size_t destSize
) {
  size_t destLen = std::strlen(dest.get());
  size_t srcLen = std::strlen(src);

  if (destLen + srcLen >= destSize) {
    srcLen = destSize - destLen - 1;

    src, src + srcLen, dest.get() + destLen
  dest[destLen + srcLen] = '\0';

int main() {
  const char* original{"Hello, World!"};
  std::cout << "Original: "
    << original << '\n';

  auto enlarged{resizeString(original, 28)};
  safeConcat(enlarged, " How are you?", 28);
  std::cout << "Enlarged: "
    << enlarged.get() << '\n';

  auto shortened{resizeString(original, 8)};
  std::cout << "Shortened: "
    << shortened.get() << '\n';
Original: Hello, World!
Enlarged: Hello, World! How are you?
Shortened: Hello,

This version uses std::unique_ptr to manage the memory, eliminating the need for manual delete calls and reducing the risk of memory leaks.

Remember, while these methods work, they're not as efficient or safe as using std::string. Whenever possible, prefer std::string for string manipulation in C++.

Answers to questions are automatically generated and may not have been reviewed.

A computer programmer
Part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Free, unlimited access

This course includes:

  • 124 Lessons
  • 550+ Code Samples
  • 96% Positive Reviews
  • Regularly Updated
  • Help and FAQ
Free, Unlimited Access

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Screenshot from Warhammer: Total War
Screenshot from Tomb Raider
Screenshot from Jedi: Fallen Order
Contact|Privacy Policy|Terms of Use
Copyright © 2024 - All Rights Reserved