Copy a string

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.

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;

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

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

 const char* src = "Hello";
 char* dst = strdup(src);

Using malloc/strcpy

 const char* src = "Hello";
 int len = strlen(src);
 char* dst = (char*)malloc(len+1);
 strcpy(dst, src);

Using malloc/strncpy

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

Using static buffer

 const char* src= "Hello";
 static char dst[80];
 strncpy(dst, src, 80);
 dst[79] = 0;

Creating another reference to an existing string

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

The same works for mutable strings, e.g.

 char[] src = "Hello";
 char* dst;
 dst = src;
 dst[1] = 'a'; // Now src contains "Hallo"

C++

Using only standard facilities

Library: STL

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

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.

#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

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

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

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

#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

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

Libraries: Qt

 // Qt
 QString src = "Hello";
 QString dst = src;

Libraries: Microsoft Foundation Classes

 // MFC
 CString src = "Hello";
 CString dst = src;

C#

 string src = "Hello";
 string dst = src;

ColdFusion

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

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

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

string src = "string";

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

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

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

Src = "Hello".
Dst = Src.

Factor

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

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

Factor string buffers (sbufs) are mutable and growable.

SBUF" Grow me!" dup "  OK." append
    SBUF" Grow me!  OK."

Convert a string buffer to a string.

SBUF" I'll be a string someday." >string .
    "I'll be a string someday."

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:

\ 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

Fortran

str2 = str1

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#

let f =
    let mutable s0 = "Hello"
    let s1 = s0
    s0 <- "Goodbye"
    printfn "%s %s" s0 s1

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

   src  =: 'hello'
   dest =: src

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.

 String src = "Hello";
 String newAlias = src;
 String strCopy = new String(src);
 
 //"newAlias == src" is true
 //"strCopy == src" is false
 //"strCopy.equals(src)" is true

Instead, maybe you want to create a StringBuffer (mutable string) from an existing String or StringBuffer:

 StringBuffer srcCopy = new StringBuffer("Hello");

JavaScript

 var src = "Hello";
 var dst =  + src;

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.

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

MAXScript

str1 = "Hello"
str2 = copy str1

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.

<lang objc> NSString *original = @"Literal String"

NSString *new = [original copy];</lang>

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

<lang objc> NSMutableString *original = @"Literal String"

NSString *immutable = [original copy];
NSMutableString *mutable = [original mutableCopy];</lang>

Copying a CString:

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

 let dst = String.copy src

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

 $src = "Hello";
 $dst = $src;

PostScript

In PostScript,

(hello) dup length string copy

Pop11

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

 vars src, dst;
 'Hello' -> src;
 copy(src) -> dst;

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

vars src='Hello';
vars dst=copy(src);

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.

Raven

Copy a string by reference:

'abc' as a
a as b

Copy a string by value:

'abc' as a
a copy as b

Ruby

 original = "hello"
 new_reference = original
 copy = original.clone      # or original.dup

Scheme

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

Seed7

 var string: dest is "";

 dest := "Hello";

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>

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:

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

or from another CharArray.array:

 val srcCopy2 = CharArray.array (CharArray.length srcCopy, #"x"); (* 'x' is just dummy character *)
 CharArray.copy {src = srcCopy, dst = srcCopy2, di = 0};

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

 " hello" is-data a
 a string.clone is-data b

V

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

 "hello" dup

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

'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