Unsafe Pointer Referencing

Some Evo classes use Pointer Referencing to copy without allocating memory, improving performance.

This can be unsafe (dangerous) in certain situations so documentation for classes/methods that do this will have a warning and a link to this page.

• These features may be avoided for maximum safety – Evo will still optimize where it can and will still be fast
• Some of these features may still be used with minimal risk

Definition

Unsafe Pointer Referencing means an object is using (referencing) a pointer it does not own that may become invalid. If the actual owner frees this pointer then the object referencing it will be invalidated, and dereferencing the pointer will crash. You're safe as long as the object referencing the pointer is cleared/destroyed before the pointer is invalidated. If the pointer is never freed (ex: string literal) then this is always safe.

Methods

The following classes have certain methods that use this technique:

• List, String

This technique is used by method overloads that take a raw pointer:

• Constructor
• operator=(src)
• set(src)

Safety:

• Referencing static data that is never freed is safe
  Example:

  evo::String str;
  str = "test";                   // Safe!

• Best: Avoid overloads that take a raw pointer, pass Ptr instead (forces an unshared copy)
  Example:

  evo::String str;
  {
      char buffer[5];
      strcpy(buffer, "test");
      str = Ptr<char>(buffer);    // Safe (unshared copy)
  }

• Call unshare() after Pointer Reference copy to force an unshared copy
  Example:

  evo::String str;
  {
      char buffer[5];
      strcpy(buffer, "test");
      str = buffer;               // Unsafe without next line
      str.unshare();              // Safe (unshared copy)
  }

• Use copy() to force an unshared copy
  Example:

  evo::String str;
  {
      char buffer[5];
      strcpy(buffer, "test");
      str.copy(buffer);           // Safe (unshared copy)
  }

Classes

The following classes rely on Pointer Referencing:

• SubString, SubList, Ptr

Safety:

• Referencing static data that is never freed is safe
  Example:

  evo::SubString str;
  str = "test";           // Safe!

• Beware referencing a local buffer with shorter life/scope
  Example:

  evo::SubString substr;
  {
      char buffer[5];
      strcpy(buffer, "test");
      substr = buffer;    // BAD!
  }
  // substr now references an invalid pointer!

• Beware referencing an object with a shorter life/scope
  Example:

  evo::SubString substr;
  {
      String str;
      str.copy("testing");
      substr = str;       // BAD!
  }   // str is destroyed
  // substr now references an invalid pointer!

• Beware of modifying (reallocating) an object while it's being referenced
  Example:

  evo::String str;
  str.copy("test");
  
  evo::SubString substr;
  substr = str;
  str.copy("test123");    // BAD! substr now references an invalid pointer since str was reallocated!

• Classes that support Sharing with each other (List, String) are safe to copy and modify in any order
  Example:

  evo::String str1;
  str1.copy("test");
  
  String str2(str1);      // str1 and str2 safely Share same data
  str1.copy("test123");   // Safe since Sharing covers modifications on either side

Read-Only Arguments

The above classes are useful for passing arguments while making the intent of passing read-only data more clear. This is especially useful in multithreaded code that may pass data between threads (with approproiate synchronization).

See also: String Passing

Example:

#include <evo/substring.h>
#include <evo/io.h>
using namespace evo;
static Console& c = con();

// Passing as SubString makes it clear str is read-only
void print(const SubString& str) {
    c.out << str << NL;
}

int main() {
    String str("test 123");
    print(str);
    print("test 456");
    return 0;
}

Output:

test 123
test 456

This is safe as long as the function assumes referenced data will not persist.

A bad example:

#include <evo/substring.h>
using namespace evo;

struct MyData {
    SubString mydata;   // DANGER: Ownership isn't clear, use String instead

    void store(const SubString& str) {
        mydata = str;   // DANGER!
    }
};

int main() {
    MyData data;
    data.store("test 123");
    return 0;
}