Copy a string

From Rosetta Code
Copy a string
You are encouraged to solve this task according to the task description, using any language you may know.

This task is about copying a string. Where it is relevant, distinguish between copying the contents of a string versus making an additional reference to an existing string.


<lang ABAP> data: lv_string1 type string value 'Test',

     lv_string2 type string.

lv_string2 = lv_string1. </lang>


Strings are immutable in ActionScript, and can safely be assigned with the assignment operator, much as they can in Java.[1] <lang ActionScript>var str1:String = "Hello"; var str2:String = str1;</lang>


Ada provides three different kinds of strings. The String type is a fixed length string. The Bounded_String type is a string with variable length up to a specified maximum size. The Unbounded_String type is a variable length string with no specified maximum size. The Bounded_String type behaves a lot like C strings, while the Unbounded_String type behaves a lot like the C++ String class.

Fixed Length String Copying.

<lang ada>Src : String := "Hello"; Dest : String := Src;</lang> Ada provides the ability to manipulate slices of strings. <lang ada>Src : String := "Rosetta Stone"; Dest : String := Src(1..7); -- Assigns "Rosetta" to Dest Dest2 : String := Src(9..13); -- Assigns "Stone" to Dest2</lang>

Bounded Length String Copying

<lang ada>-- Instantiate the generic package Ada.Strings.Bounded.Generic_Bounded_Length with a maximum length of 80 characters package Flexible_String is new Ada.Strings.Bounded.Generic_Bounded_Length(80); use Flexible_String;

Src : Bounded_String := To_Bounded_String("Hello"); Dest : Bounded_String := Src;</lang> Ada Bounded_String type provides a number of functions for dealing with slices.

Unbounded Length String Copying

<lang ada>-- The package Ada.Strings.Unbounded contains the definition of the Unbounded_String type and all its methods Src : Unbounded_String := To_Unbounded_String("Hello"); Dest : Unbounded_String := Src;</lang>


In ALGOL 68 strings are simply flexible length arrays of CHAR;

<lang algol68>(

 STRING src:="Hello", dest;



<lang autohotkey>src := "Hello" dst := src</lang>


<lang awk>BEGIN {

 a = "a string"
 b = a
 sub(/a/, "X", a) # modify a
 print b  # b is a copy, not a reference to...



Works with: QuickBasic version 4.5
Works with: PB version 7.1
 src$ = "Hello"
 dst$ = src$

Batch File

Since the only variables are environment variables, creating a string copy is fairly straightforward: <lang dos>set src=Hello set dst=%src%</lang>


<lang bbcbasic> source$ = "Hello, world!"

     REM Copy the contents of a string:
     copy$ = source$
     PRINT copy$
     REM Make an additional reference to a string:
     !^same$ = !^source$
     ?(^same$+4) = ?(^source$+4)
     ?(^same$+5) = ?(^source$+5)
     PRINT same$</lang>


<lang c>#include <stdlib.h> /* exit(), free() */

  1. include <stdio.h> /* fputs(), perror(), printf() */
  2. include <string.h> /* memcpy(), strdup(), strlen() */

int main() { size_t len; char src[] = "Hello"; char dst[80], *dst2, *dst3;

/* * Option 1. Use memcpy() to copy to a static buffer. */ len = strlen(src); if (len >= sizeof dst) { fputs("The buffer is too small!\n", stderr); exit(1); } memcpy(dst, src, len + 1 /* final '\0' */);

/* * Option 2. Use strdup() to allocate a copy. * * strdup() is part of POSIX, but strdup() is now so common * that almost all systems without POSIX still have strdup(). */ dst2 = strdup(src); if (dst2 == NULL) { /* failed to allocate memory */ perror("strdup"); exit(1); }

/* * Option 3. Create another reference to an existing string. */ dst3 = src;

src[0] = 'Y'; /* modify original string */ printf("src: %s\n", src); printf("dst: %s\n", dst); printf("dst2: %s\n", dst2); printf("dst3: %s\n", dst3);

free(dst2); /* free memory from strdup() */

return 0; }</lang>


src:  Yello
dst:  Hello
dst2: Hello
dst3: Yello


Using only standard facilities

Library: STL

<lang cpp>#include <string> std::string src = "Hello"; std::string dst = src;</lang>

Standard C++ strings are not guaranteed to be stored contiguous, as needed for C functions, and it's only possible to get pointers to constant C strings. Therefore if the C function modifies the string, it has to be copied into a C string. There are several ways, depending on the needs:

Using a std::vector allows C++ to manage the memory of the copy. Since C++2003 (TR1), std::vector is guaranteed to be contiguous; but even before, there was no implementation which wasn't.

<lang cpp>#include <string>

  1. include <vector>

std::string s = "Hello"; {

 // copy into a vector
 std::vector<char> string_data(s.begin(), s.end());
 // append '\0' because C functions expect it
 // call C function
 // copy resulting C string back to s
 s = (&string_data[0]);

} // string_data going out of scope -> the copy is automatically released</lang>

Another way is to manage your memory yourself and use C functions for the copy:

<lang cpp>#include <string>

  1. include <cstring> // For C string functions (strcpy)

std::string s = "Hello"; // allocate memory for C string char* cs = new char[s.length() + 1]; // copy string into modifyable C string (s.c_str() gives constant C string) std::strcpy(cs, s.c_str()); // call C function modify(cs); // copy result back into s s = cs; // get rid of temporary buffer delete[] cs;</lang>

If the C function calls free or realloc on its argument, new[] cannot be used, but instead malloc must be called:

<lang cpp>#include <string>

  1. include <cstring>
  2. include <cstdlib> // for malloc

std::string s = "Hello"; // allocate memory for C string char* cs = (char*)std::malloc(s.length()+1); // copy the string std::strcpy(cs, s.c_str()); // call C function which may call realloc modify(&cs); // copy result back to s s = cs; // get rid of temporary buffer std::free(cs); // delete or delete[] may not be used here</lang>

Using string types supplied by specific compiler-provided or external libraries

Library: Qt
Uses: Qt (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/Qt/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

<lang cpp>// Qt QString src = "Hello"; QString dst = src;</lang>

Uses: Microsoft Foundation Classes (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/Microsoft Foundation Classes/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

<lang cpp>// MFC CString src = _T("Hello"); CString dst = src;</lang>


<lang csharp>string src = "Hello"; string dst = src;</lang>


<lang clojure> (let [s "hello"

     s1 s]
 (println s s1))



In ColdFusion, only complex data types (structs, objects, etc.) are passed by reference. Hence, any string copy operations are by value.

<lang coldfusion><cfset stringOrig = "I am a string." /> <cfset stringCopy = stringOrig /></lang>

Common Lisp

<lang lisp>(let* ((s1 "Hello")  ; s1 is a variable containing a string

      (s1-ref s1)             ; another variable with the same value
      (s2     (copy-seq s1))) ; s2 has a distinct string object with the same contents
 (assert (eq s1 s1-ref))      ; same object
 (assert (not (eq s1 s2)))    ; different object
 (assert (equal s1 s2))       ; same contents
 (fill s2 #\!)                ; overwrite s2
 (princ s1)                  
 (princ s2))                  ; will print "Hello!!!!!"</lang>


<lang d>string src = "string";

// copy contents: auto dest = src.dup;

// copy reference with copy-on-write: auto dest2 = src;</lang>


Delphi strings are reference counted with copy on write semantics.

<lang Delphi>program CopyString;



 s1: string;
 s2: string;


 s1 := 'Goodbye';
 s2 := s1; // S2 points at the same string as S1
 s2 := s2 + ', World!'; // A new string is created for S2



Goodbye, World!


E is a pass-references-by-value object-oriented language, and strings are immutable, so there is never a need for or benefit from copying a string. Various operations, such as taking the substring (run) from the beginning to the end ( might create a copy, but this is not guaranteed.


<lang erlang>Src = "Hello". Dst = Src.</lang>


.NET strings are immutable, so it is usually not useful to make a deep copy. However if needed, it is possible using a static method of the System.String type: <lang fsharp>let str = "hello" let additionalReference = str let deepCopy = System.String.Copy( str )

printfn "%b" <| System.Object.ReferenceEquals( str, additionalReference ) // prints true printfn "%b" <| System.Object.ReferenceEquals( str, deepCopy ) // prints false</lang>


Factor strings are mutable but not growable. Strings will be immutable in a future release.

<lang factor>"This is a mutable string." dup ! reference "Let's make a deal!" dup clone  ! copy "New" " string" append .  ! new string

   "New string"</lang>

Factor string buffers (sbufs) are mutable and growable.

<lang factor>SBUF" Grow me!" dup " OK." append

   SBUF" Grow me!  OK."</lang>

Convert a string buffer to a string.

<lang factor>SBUF" I'll be a string someday." >string .

   "I'll be a string someday."</lang>


Forth strings are generally stored in memory as prefix counted string, where the first byte contains the string length. However, on the stack they are most often represented as <addr cnt> pairs. Thus the way you copy a string depends on where the source string comes from:

<lang forth>\ Allocate two string buffers create stringa 256 allot create stringb 256 allot

\ Copy a constant string into a string buffer s" Hello" stringa place

\ Copy the contents of one string buffer into another stringa count stringb place</lang>


<lang fortran>str2 = str1</lang>

Because Fortran uses fixed length character strings if str1 is shorter than str2 then str2 is padded out with trailing spaces. If str1 is longer than str2 it is truncated to fit.


Note that the DIM statement is optional in Gambas.

<lang gambas> DIM src AS String DIM dst AS String src = "Hello" dst = src </lang>


<lang gap>#In GAP strings are lists of characters. An affectation simply copy references a := "more"; b := a; b{[1..4]} := "less"; a;

  1. "less"
  1. Here is a true copy

a := "more"; b := ShallowCopy(a); b{[1..4]} := "less"; a;

  1. "more"</lang>


<lang GML>src = "string" dest = src</lang>


Just use assignment: <lang go>src := "Hello" dst := src</lang> Strings in Go are immutable. Because of this there is no need to distinguish between copying the contents and making an additional reference. Technically, Go strings are immutable byte slices. A slice is an object that contains a reference to an underlying array. In the assignment shown above, a new slice object is created for dst. Its internal reference is likely to point to the same underlying array as src, but the language does not specify this behavior or make any guarantees about it.


The dynamics of references and object creation are very much the same as in Java. However, the meaning of the equality (==) operator is different in Groovy, so we show those differences here, even though they are not relevant to the actual copying.

Example and counter-example: <lang groovy>def string = 'Scooby-doo-bee-doo' // assigns string object to a variable reference def stringRef = string // assigns another variable reference to the same object def stringCopy = new String(string) // copies string value into a new object, and assigns to a third variable reference</lang>

Test Program: <lang groovy>assert string == stringRef // they have equal values (like Java equals(), not like Java ==) assert // they are references to the same objext (like Java ==) assert string == stringCopy // they have equal values assert ! // they are references to different objects (like Java !=)</lang>

Caveat Lector: Strings are immutable objects in Groovy, so it is wasteful and utterly unnecessary to ever make copies of them within a Groovy program.


In Haskell, every value is immutable, including Strings. So one never needs to copy them; references are shared.


<lang hicest>src = "Hello World" dst = src</lang>

Icon and Unicon

Strings in Icon are immutable. <lang icon>procedure main()

   a := "qwerty"
   b := a
   b[2+:4] := "uarterl"
   write(a," -> ",b)


Under the covers 'b' is created as a reference to the same string as 'a'; the sub-string assignment creates a new copy of the string. However, there is no way to tell this in the language. While most of the time this is transparent, programs that create very long strings through repeated concatenation need to avoid generating intermediate strings. Instead using a list and concatenating at the last minute can perform much better.

Note that strings are indicated using double quotes. However, single quotes are another type called character sets or csets.


<lang j>src =: 'hello' dest =: src</lang>

J has copy-on-write semantics. So both src and dest are references to the same memory, until src changes, at which time dest retains a copy of the original value of src.


In Java, Strings are immutable, so it doesn't make that much difference to copy it. <lang java>String src = "Hello"; String newAlias = src; String strCopy = new String(src);

//"newAlias == src" is true //"strCopy == src" is false //"strCopy.equals(src)" is true</lang>

Instead, maybe you want to create a StringBuffer (mutable string) from an existing String or StringBuffer: <lang java>StringBuffer srcCopy = new StringBuffer("Hello");</lang>


<lang javascript>var src = "Hello"; var dst = + src;</lang>

Note that '' + src concatenation was used to make sure that the string is actually copied instead of being passed by reference, but since strings in JavaScript are immutable and always compared by value, there is no way to test whether any two given variables are both references to the same string or two distinct strings which just happen to have the same value. So in practice this code is exactly equivalent: <lang javascript>var src = "Hello"; var dst = src;</lang> even though the string might or might not have been actually copied.


<lang joy>"hello" dup</lang>

Strings are immutable.


<lang KonsolScript>Var:String str1 = "Hello"; Var:String str2 = str1;</lang>

Liberty BASIC

<lang lb>src$ = "Hello" dest$ = src$ print src$ print dest$



<lang Lisaac>+ scon : STRING_CONSTANT; + svar : STRING;

scon := "sample"; svar := STRING.create 20; svar.copy scon; svar.append "!\n";

svar.print;</lang> STRING_CONSTANT is immutable, STRING is not.

As a functional language, words are normally treated as symbols and cannot be modified. The EQUAL? predicate compares contents instead of identity. In UCB Logo the .EQ predicate tests for "thing" identity. <lang logo>make "a "foo make "b "foo print .eq :a :b  ; true, identical symbols are reused

make "c :a print .eq :a :c  ; true, copy a reference

make "c word :b "||  ; force a copy of the contents of a word by appending the empty word print equal? :b :c  ; true print .eq :b :c  ; false</lang>


Lua strings are immutable, so only one reference to each string exists. <lang lua> a = "string" b = a print(a == b) -->true print(b) -->string</lang>


<lang Mathematica>a="Hello World" b=a</lang>


<lang MATLAB>string1 = 'Hello'; string2 = string1;</lang>


<lang maxscript>str1 = "Hello" str2 = copy str1</lang>


Metafont will always copy a string (does not make references).

<lang metafont>string s, a; s := "hello"; a := s; s := s & " world"; message s;  % writes "hello world" message a;  % writes "hello" end</lang>


Strings in Modula-3 have the type TEXT. <lang modula3>VAR src: TEXT := "Foo"; VAR dst: TEXT := src;</lang>


<lang>SET S1="Greetings, Planet" SET S2=S1</lang>


Immutable strings - since they are immutable, you may get the same instance with its references count increased. Or, you can get a copy which is mutable if you use mutableCopy. Remember that both copy and mutableCopy return a retained instance.

<lang objc>NSString *original = @"Literal String"; NSString *new = [original copy]; NSString *newMutable = [original mutableCopy];</lang>

Mutable strings - you can get either new mutable (if you use mutableCopy) or immutable (if you use copy) string:

<lang objc>NSMutableString *original = [NSMutableString stringWithString:@"Literal String"]; NSString *immutable = [original copy]; NSMutableString *mutable = [original mutableCopy];</lang>

Copying a CString into an NSString:

<lang objc>const char *cstring = "I'm a plain C string"; NSString *string = [NSString stringWithUTF8String:cstring];</lang>

Copying from data, possibly not null terminated:

<lang objc>char bytes[] = "some data"; NSString *string = [[NSString alloc] initWithBytes:bytes length:9 encoding:NSASCIIStringEncoding];</lang>

And of course, if a C string is needed, you can use standard functions like strcpy.


<lang objeck> a := "GoodBye!"; b := a; </lang>


<lang ocaml>let dst = String.copy src</lang>


<lang octave>str2 = str1</lang>


Assignment in GP always copies. <lang parigp>s1=s</lang>

In Pari, strings can be copied and references can be made. <lang C>GEN string_copy = gcopy(string); GEN string_ref = string</lang>


<lang pascal> program in,out;


  pString = ^string;


  s1,s2 : string ;
  pStr  : pString ;


  /* direct copy */
  s1 := 'Now is the time for all good men to come to the aid of their party.'
  s2 := s1 ;
  /* By Reference */
  pStr := @s1 ;
  pStr := @s2 ;

end; </lang>


To copy a string, just use ordinary assignment:

<lang perl>my $original = 'Hello.'; my $new = $original; $new = 'Goodbye.'; print "$original\n"; # prints "Hello."</lang>

To create a reference to an existing string, so that modifying the referent changes the original string, use a backslash:

<lang perl>my $original = 'Hello.'; my $ref = \$original; $$ref = 'Goodbye.'; print "$original\n"; # prints "Goodbye."</lang>

If you want a new name for the same string, so that you can modify it without dereferencing a reference, assign a reference to a typeglob:

<lang perl>my $original = 'Hello.'; our $alias; local *alias = \$original; $alias = 'Good evening.'; print "$original\n"; # prints "Good evening."</lang>

Note that our $alias, though in most cases a no-op, is necessary under stricture. Beware that local binds dynamically, so any subroutines called in this scope will see (and possibly modify!) the value of $alias assigned here.

To make a lexical variable that is an alias of some other variable, the Lexical::Alias module can be used: <lang perl>use Lexical::Alias; my $original = 'Hello.'; my $alias; alias $alias, $original; $alias = 'Good evening.'; print "$original\n"; # prints "Good evening."</lang>

Perl 6

There is no special handling needed to copy a string; just assign it to a new variable: <lang perl6>my $original = 'Hello.'; my $copy = $original; say $copy; # prints "Hello." $copy = 'Goodbye.'; say $copy; # prints "Goodbye." say $original; # prints "Hello."</lang>

You can also bind a new variable to an existing one so that each refers to, and can modify the same string. <lang perl6>my $original = 'Hello.'; my $bound := $original; say $bound; # prints "Hello." $bound = 'Goodbye.'; say $bound; # prints "Goodbye." say $original; # prints "Goodbye."</lang>

You can also create a read-only binding which will allow read access to the string but prevent modification except through the original variable. <lang perl6>my $original = 'Hello.'; my $bound-ro ::= $original; say $bound-ro; # prints "Hello." try {

 $bound-ro = 'Runtime error!';
   say "$!";         # prints "Cannot modify readonly value"

}; say $bound-ro; # prints "Hello." $original = 'Goodbye.'; say $bound-ro; # prints "Goodbye."</lang>


<lang php>$src = "Hello"; $dst = $src;</lang>


<lang PicoLisp>(setq Str1 "abcdef") (setq Str2 Str1) # Create a reference to that symbol (setq Str3 (name Str1)) # Create new symbol with name "abcdef"</lang>


<lang pike>int main(){

  string hi = "Hello World.";
  string ih = hi;



In Pop11 normal data are represented by references, so plain assignment will copy references. To copy data one has to use copy procedure:

<lang pop11>vars src, dst; 'Hello' -> src; copy(src) -> dst;</lang>

One can also combine assignment (initialization) with variable declarations:

<lang pop11>vars src='Hello'; vars dst=copy(src);</lang>


In PostScript, <lang postscript>(hello) dup length string copy</lang>


Since PowerShell uses .NET behind the scenes and .NET strings are immutable you can simply assign the same string to another variable without breaking anything: <lang powershell>$str = "foo" $dup = $str</lang> To actually create a copy the Clone() method can be used: <lang powershell>$dup = $str.Clone()</lang>


<lang PureBasic>src$ = "Hello" dst$ = src$</lang>


Works with: Python version 2.3, 2.4, and 2.5

Since strings are immutable, all copy operations return the same string. Probably the reference is increased.

<lang python>>>> src = "hello" >>> a = src >>> b = src[:] >>> import copy >>> c = copy.copy(src) >>> d = copy.deepcopy(src) >>> src is a is b is c is d True</lang>

To actually copy a string:

<lang python>>>> a = 'hello' >>> b = .join(a) >>> a == b True >>> b is a ### Might be True ... depends on "interning" implementation details! False</lang>

As a result of object "interning" some strings such as the empty string and single character strings like 'a' may be references to the same object regardless of copying. This can potentially happen with any Python immutable object and should be of no consequence to any proper code.

Be careful with is - use it only when you want to compare the identity of the object. To compare string values, use the == operator. For numbers and strings any given Python interpreter's implementation of "interning" may cause the object identities to coincide. Thus any number of names to identical numbers or strings might become references to the same objects regardless of how those objects were derived (even if the contents were properly "copied" around). The fact that these are immutable objects makes this a reasonable behavior.


Copy a string by value: <lang R>str1 <- "abc" str2 <- str1</lang>


Copy a string by reference:

<lang raven>'abc' as a a as b</lang>

Copy a string by value:

<lang raven>'abc' as a a copy as b</lang>



   Title: "String Copy"
   Date: 2009-12-16
   Author: oofoe


x: y: "Testing." y/2: #"X" print ["Both variables reference same string:" mold x "," mold y]

x: "Slackeriffic!" print ["Now reference different strings:" mold x "," mold y]

y: copy x  ; String copy here! y/3: #"X"  ; Modify string. print ["x copied to y, then modified:" mold x "," mold y]

y: copy/part x 7 ; Copy only the first part of y to x. print ["Partial copy:" mold x "," mold y]

y: copy/part skip x 2 3 print ["Partial copy from offset:" mold x "," mold y]</lang>


Script: "String Copy" (16-Dec-2009)
Both variables reference same string: "TXsting." , "TXsting."
Now reference different strings: "Slackeriffic!" , "TXsting."
x copied to y, then modified: "Slackeriffic!" , "SlXckeriffic!"
Partial copy: "Slackeriffic!" , "Slacker"
Partial copy from offset: "Slackeriffic!" , "ack"


<lang Retro>"this is a string" dup tempString</lang>


<lang rexx>src = "this is a string" dst = src </lang>


<lang RLaB> >> s1 = "A string" A string >> s2 = s1 A string </lang>


<lang ruby>original = "hello" new_reference = original copy = original.clone # or original.dup</lang>


<lang sather>class MAIN is

 main is
   s  ::= "a string";
   s1 ::= s;
   -- s1 is a copy



<lang scheme>(define dst (string-copy src))</lang>


<lang seed7>var string: dest is "";

dest := "Hello";</lang>


<lang shiny>src: 'hello' cpy: src</lang>


<lang slate>[ | :s | s == s copy] applyTo: {'hello'}. "returns False"</lang>


<lang smalltalk>|s1 s2| "bind the var s1 to the object string on the right" s1 := 'i am a string'. "bind the var s2 to the same object..." s2 := s1. "bind s2 to a copy of the object bound to s1" s2 := (s1 copy).</lang>


<lang snobol4>

  • copy a to b
         b = a = "test"
         output = a
         output = b
  • change the copy
         b "t" = "T"
         output = b




Standard ML

In Standard ML, strings are immutable, so you don't copy it.

Instead, maybe you want to create a CharArray.array (mutable string) from an existing string: <lang sml>val src = "Hello"; val srcCopy = CharArray.array (size src, #"x"); (* 'x' is just dummy character *) CharArray.copyVec {src = src, dst = srcCopy, di = 0}; src = CharArray.vector srcCopy; (* evaluates to true *)</lang>

or from another CharArray.array: <lang sml>val srcCopy2 = CharArray.array (CharArray.length srcCopy, #"x"); (* 'x' is just dummy character *) CharArray.copy {src = srcCopy, dst = srcCopy2, di = 0};</lang>


<lang tcl>set src "Rosetta Code" set dst $src</lang> Tcl copies strings internally when needed. To be exact, it uses a basic value model based on simple objects that are immutable when shared (i.e., when they have more than one effective reference to them); when unshared, they can be changed because the only holder of a reference has to be the code requesting the change. At the script level, this looks like Tcl is making a copy when the variable is assigned as above, but is more efficient in the common case where a value is not actually modified.


<lang ti83b>

"Rosetta Code"→Str1



<lang ti89b>

"Rosetta Code"→str1



<lang toka>" hello" is-data a a string.clone is-data b</lang>


Strings are immutable character sequences, so copying a string just means duplicating the reference at the top of the stack: <lang trith>"Hello" dup</lang>


<lang tuscript> $$ MODE TUSCRIPT str="Hello" dst=str </lang>


dup really makes a reference, but the language is functional so the string is immutable.

<lang v>"hello" dup</lang>

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

<lang vbnet>'Immutable Strings Dim a = "Test string" Dim b = a 'reference to same string Dim c = New String(a.ToCharArray) 'new string, normally not used

'Mutable Strings Dim x As New Text.StringBuilder("Test string") Dim y = x 'reference Dim z = New Text.StringBuilder(x.ToString) 'new string</lang>

Alternatively, you can use, with all versions of the .NET framework: <lang vbnet>Dim a As String = "Test String" Dim b As String = String.Copy(a) ' New string</lang>

ZX Spectrum Basic

<lang basic> 10 LET a$ = "Hello": REM a$ is the original string 20 LET b$ = a$: REM b$ is the copy</lang>