Copy a string

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.

Ada

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>

ALGOL 68

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

<lang algol68>(

 STRING src:="Hello", dest;
 dest:=src

)</lang>

AutoHotkey

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

AWK

<lang awk>BEGIN {

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

}</lang>

BASIC

Works with: QuickBasic version 4.5

Works with: PB version 7.1

 src$ = "Hello"
 dst$ = src$

C

Using strdup

<lang c>const char* src = "Hello"; char* dst = strdup(src);</lang>

Using malloc/strcpy

<lang c>const char* src = "Hello"; int len = strlen(src); char* dst = (char*)malloc(len+1); strcpy(dst, src);</lang>

Using malloc/strncpy

<lang c>const char* src = "Hello"; int len = strlen(src); char* dst = (char*)malloc(len+1); strncpy(dst, src, len+1); dst[len] = 0;</lang>

Using static buffer

<lang c>const char* src= "Hello"; static char dst[80]; strncpy(dst, src, 80); dst[79] = 0;</lang>

Creating another reference to an existing string

<lang c>const char* src = "Hello"; const char* dst; dst = src; /* now dst refers top the same string as src */</lang>

The same works for mutable strings, e.g. <lang c>char[] src = "Hello"; char* dst; dst = src; dst[1] = 'a'; // Now src contains "Hallo"</lang>

C++

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>

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
 string_data.push_back('\0');
 // call C function
 modify(&string_data[0]);
 // 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>

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>

include <cstring>
include <cstdlib> // for malloc

std::string s = "Hello"; // allocate memory for C string char* cs = (char*)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 free(cs); // delete or delete[] may not be used here</lang>

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

Library: Qt

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

Library: Microsoft Foundation Classes

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

C#

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

ColdFusion

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

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>

D

<lang d>string src = "string";

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

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

E

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 (someString.run(0)) might create a copy, but this is not guaranteed.

Erlang

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

Factor

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

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>

Fortran

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.

F#

<lang fsharp>let f =

   let mutable s0 = "Hello"
   let s1 = s0
   s0 <- "Goodbye"
   printfn "%s %s" s0 s1</lang>

prints Goodbye Hello when run.

Groovy

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 string.is(stringRef) // they are references to the same objext (like Java ==) assert string == stringCopy // they have equal values assert ! string.is(stringCopy) // 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.

Haskell

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

J

<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 gets a copy of the original value of src.

Java

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>

JavaScript

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

Joy

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

Strings are immutable.

Lisaac

<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.

Logo

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

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>

Mathematica

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

MAXScript

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

Metafont

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>

Modula-3

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

Objective-C

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.

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

Mutable strings - you can get either new mutable or immutable string:

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

Copying a CString:

<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.

OCaml

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

Octave

Perl

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 $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>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.

PHP

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

PicoLisp

<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>

Pike

<lang pike>int main(){

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

}</lang>

PostScript

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

Pop11

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>

PowerShell

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>

PureBasic

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

Python

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.

R

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

REBOL

<lang REBOL>REBOL [

   Title: "String Copy"
   Date: 2009-12-16
   Author: oofoe
   URL: http://rosettacode.org/wiki/Copy_a_string

]

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>

Output:

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"

Raven

Copy a string by reference:

Copy a string by value:

REXX

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

Ruby

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

Scheme

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

Seed7

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

dest := "Hello";</lang>

Slate

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

Smalltalk

<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>

SNOBOL4

copy a to b

         b = a = "test"
         output = a
         output = b

change the copy

         b "t" = "T"
         output = b

end</lang>

Output

 test
 test
 Test

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>

Tcl

<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.

Toka

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

V

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>