Limitation of Array of Pointers to Strings in C

Array of pointers to strings is a widely used data structure in C programming. While it provides flexibility and efficient string management, it also has certain limitations that programmers need to be aware of. In this article, we will explore the limitations of the array of pointers to strings in C, and understand how to overcome them for effective programming.

Limited Size and Fixed Length

One of the primary limitations of an array of pointers to strings is its fixed size and length. Consider the following:

  1. Limited Size:
    • The size of the array needs to be determined at compile-time.
    • It may not be possible to accommodate a variable number of strings or dynamically adjust the size.
  2. Fixed Length:
    • Strings within the array have fixed lengths, determined by the allocated memory.
    • It becomes challenging to handle strings of different lengths or accommodate larger strings.

Memory Fragmentation

Another limitation of the array of pointers to strings is the potential for memory fragmentation. Let’s explore this further:

  1. Non-Contiguous Memory:
    • Each string in the array is stored in separate memory locations.
    • This can lead to fragmented memory, with strings scattered across different memory areas.
  2. Inefficient Memory Utilization:
    • Memory fragmentation can result in inefficient memory utilization.
    • It may become challenging to allocate and deallocate memory efficiently for string storage.

Lack of Dynamic Resizing

The array of pointers to strings lacks the ability to dynamically resize itself. Consider the following:

  1. Inability to Resize:
    • Once the array is declared and initialized, it cannot be resized automatically.
    • Adding or removing strings from the array requires manual memory reallocation and string copying.
  2. Time and Space Complexity:
    • Dynamic resizing involves additional time and space complexity.
    • The programmer needs to carefully manage memory allocation and deallocation to avoid memory leaks or excessive overhead.

Difficulty in Sorting and Searching

Sorting and searching operations can be challenging with an array of pointers to strings. Let’s discuss this limitation:

  1. Inefficient Sorting:
    • Sorting the array of pointers to strings based on string content can be complex.
    • Custom sorting algorithms or libraries may be required to handle such operations efficiently.
  2. Inefficient Searching:
    • Searching for a particular string within the array can involve traversing multiple pointers.
    • It may not be as efficient as other data structures like hash tables or binary search trees.

Workarounds and Alternative Data Structures

To overcome the limitations of the array of pointers to strings, consider the following workarounds and alternative data structures:

  1. Dynamic Memory Allocation:
    • Use dynamic memory allocation techniques like malloc() and free() to handle variable-sized strings.
  2. Linked List:
    • Implement a linked list of string nodes to allow dynamic resizing and efficient memory utilization.
  3. Hash Tables or Binary Search Trees:
    • Utilize data structures like hash tables or binary search trees for efficient searching and sorting operations.


While the array of pointers to strings is a useful data structure in C, it does have its limitations. By understanding and considering these limitations, programmers can make informed decisions about when to use this data structure and how to overcome its shortcomings. Exploring alternative data structures and adopting appropriate techniques can enhance string manipulation and overall program efficiency.