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.

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

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$

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>

BBC BASIC

Works with: BBC BASIC for Windows

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

Bracmat

Because in Bracmat strings are unalterable, you never want to copy a string. Still, you will obtain a copy of a string by overflowing the reference counter of the string. (Currently, reference counters on strings and on most operators are 10 bits wide. The = operator has a much wider 'inexhaustible' reference counter, because it anchors alterable objects.) Still, you won't be able to test whether you got the original or a copy other than by looking at overall memory usage of the Bracmat program at the OS-level or by closely timing comparison operations. You obtain a new reference to a string or a copy of the string by simple assignment using the = or the : operator: <lang bracmat>abcdef:?a; !a:?b;

c=abcdef; !c:?d;

!a:!b { variables a and b are the same and probably referencing the same string } !a:!d { variables a and d are also the same but not referencing the same string } </lang>

C

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

include <stdio.h> /* fputs(), perror(), printf() */
include <string.h>

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

/* * Option 1. Use strcpy() from <string.h>. * * DANGER! strcpy() can overflow the destination buffer. * strcpy() is only safe is the source string is shorter than * the destination buffer. We know that "Hello" (6 characters * with the final '\0') easily fits in dst1 (80 characters). */ strcpy(dst1, src);

/* * Option 2. Use strlen() and memcpy() from <string.h>, to copy * strlen(src) + 1 bytes including the final '\0'. */ len = strlen(src); if (len >= sizeof dst2) { fputs("The buffer is too small!\n", stderr); exit(1); } memcpy(dst2, src, len + 1);

/* * Option 3. Use strdup() from <string.h>, to allocate a copy. */ dst3 = strdup(src); if (dst3 == NULL) { /* Failed to allocate memory! */ perror("strdup"); exit(1); }

/* Create another reference to the source string. */ ref = src;

/* Modify the source string, not its copies. */ memset(src, '-', 5);

printf(" src: %s\n", src); /* src: ----- */ printf("dst1: %s\n", dst1); /* dst1: Hello */ printf("dst2: %s\n", dst2); /* dst2: Hello */ printf("dst3: %s\n", dst3); /* dst3: Hello */ printf(" ref: %s\n", ref); /* ref: ----- */

/* Free memory from strdup(). */ free(dst3);

return 0; }</lang>

Library: BSD libc

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

include <stdio.h> /* fputs(), printf() */
include <string.h>

int main() { char src[] = "Hello"; char dst[80];

/* Use strlcpy() from <string.h>. */ if (strlcpy(dst, src, sizeof dst) >= sizeof dst) { fputs("The buffer is too small!\n", stderr); exit(1); }

memset(src, '-', 5); printf("src: %s\n", src); /* src: ----- */ printf("dst: %s\n", dst); /* dst: Hello */

return 0; }</lang>

C++

Using only standard facilities

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

This example is in need of improvement:

This talks about interfacing pre-C++11 C++ with C API functions that modify character arrays. Does foreign language API really have to be discussed in string copying task?

Prior to C++11, standard C++ strings were 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*)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>

Library: Microsoft Foundation Classes

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>

C#

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

Clojure

<lang clojure> (let [s "hello"

     s1 s]
 (println s s1))

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

Delphi

Delphi strings are reference counted with copy on write semantics.

<lang Delphi>program CopyString;

{$APPTYPE CONSOLE}

var

 s1: string;
 s2: string;

begin

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

 Writeln(s1);
 Writeln(s2);

end.</lang>

Output:

Goodbye
Goodbye, World!

DWScript

DWScript strings are value-type, from the language point of view, you can't have a reference to a String, no more than you can have a reference to an Integer or a Float (unless you wrap in an object of course).

Internally they're transparently implemented via either immutable reference or copy-on-write.

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>

Euphoria

Works with: Euphoria version 4.0.3, 4.0.0 RC1 and later

Arrays in many languages are constrained to have a fixed number of elements, and those elements must all be of the same type. Euphoria eliminates both of those restrictions by defining all arrays (sequences) as a list of zero or more Euphoria objects whose element count can be changed at any time. When you retrieve a sequence element, it is not guaranteed to be of any type. You, as a programmer, need to check that the retrieved data is of the type you'd expect, Euphoria will not. The only thing it will check is whether an assignment is legal. For example, if you try to assign a sequence to an integer variable, Euphoria will complain at the time your code does the assignment.

<lang Euphoria>sequence first = "ABC" sequence newOne = first</lang>

F#

.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

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.

Gambas

Note that the DIM statement is optional in Gambas.

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

GAP

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

"less"

Here is a true copy

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

"more"</lang>

GML

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

Go

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.

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.

GUISS

<lang guiss>Start.Programs,Accessories,Notepad, Type:Hello world[pling],Highlight:Hello world[pling], Menu,Edit,Copy,Menu,Edit,Paste</lang>

Haskell

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

HicEst

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

end</lang>

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.

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

KonsolScript

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

LabVIEW

In LabVIEW, one can simply wire an input to more than one output.
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Liberty BASIC

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

</lang>

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>

MATLAB

<lang MATLAB>string1 = 'Hello'; string2 = string1;</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>

Mirah

<lang mirah>src = "Hello" new_alias = src

puts 'interned strings are equal' if src == new_alias

str_copy = String.new(src) puts 'non-interned strings are not equal' if str_copy != src puts 'compare strings with equals()' if str_copy.equals(src) </lang>

Modula-3

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

MUMPS

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

Nemerle

Nemerle gives you the option of declaring a variable - even a string - as mutable, so the caveats of languages with only immutable strings don't necessarily apply. However, Nemerle binds the value of the string to the new name when copying; to sort of emulate copying a reference you can use lazy evaluation. <lang Nemerle>using System; using System.Console; using Nemerle;

module StrCopy {

   Main() : void
   {
       mutable str1 = "I am not changed";      // str1 is bound to literal
       def str2 = lazy(str1);                  // str2 will be bound when evaluated
       def str3 = str1;                        // str3 is bound to value of str1
       str1 = "I am changed";                  // str1 is bound to new literal
       Write($"$(str1)\n$(str2)\n$(str3)\n");  // str2 is bound to value of str1
       // Output: I am changed
       //         I am changed
       //         I am not changed
   }

}</lang>

NewLISP

<lang NewLISP>(define (assert f msg) (if (not f) (println msg)))

(setq s "Greetings!" c (copy s)) (reverse c) ; Modifies c in place.

(assert (= s c) "Strings not equal.")</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 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.

Objeck

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

OCaml

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

Octave

PARI/GP

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>

Pascal

<lang pascal> program in,out;

type

  pString = ^string;

var

  s1,s2 : string ;
  pStr  : pString ;

begin

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

  writeln(s1);
  writeln(s2);

  /* By Reference */
  pStr := @s1 ;
  writeln(pStr^);

  pStr := @s2 ;
  writeln(pStr^);

end; </lang>

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 $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!';
 CATCH {
   say "$!";         # prints "Cannot modify readonly value"
 };

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

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>

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>

PostScript

In PostScript, <lang postscript>(hello) dup length string copy</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>

ProDOS

<lang ProDOS>editvar /newvar /value=a /userinput=1 /title=Enter a string to be copied: editvar /newvar /value=b /userinput=1 /title=Enter current directory of the string: editvar /newvar /value=c /userinput=1 /title=Enter file to copy to: copy -a- from -b- to -c- </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>

Raven

Copy a string by reference:

Copy a string by value:

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"

Retro

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

REXX

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

RLaB

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

Ruby

<lang ruby>original = "hello" reference = original copy1 = original.dup # instance of original.class copy2 = String.new(original) # instance of String</lang>

Sather

<lang sather>class MAIN is

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

end;</lang>

Scheme

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

Seed7

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

dest := "Hello";</lang>

Shiny

<lang shiny>src: 'hello' cpy: src</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.

TI-83 BASIC

"Rosetta Code"→Str1

Str1→Str2

</lang>

TI-89 BASIC

"Rosetta Code"→str1

str1→str2

</lang>

Toka

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

Trith

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>

TUSCRIPT

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

UNIX Shell

<lang sh>foo="Hello" bar=$foo # This is a copy of the string</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>

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>