Copy a string: Difference between revisions
Note about string singletons |
no Fortran implementation |
||
Line 25:
Src : Unbounded_String := To_Unbounded_String("Hello");
Dest : Unbounded_String := Src;
==[[BASIC]]==
[[Category:BASIC]]
Line 130 ⟶ 131:
\ Copy the contents of one string buffer into another
stringa count stringb place
==[[Java]]==
|
Revision as of 17:48, 21 September 2007
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.
Ada
Ada provides three diffferent 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.
Src : String := "Hello"; Dest : String := Src;
Ada provides the ability to manipulate slices of strings.
Src : String "Rosetta Stone"; Dest : String := Src(1..7); -- Assigns "Rosetta" to Dest Dest2 : String := Src(9..13); -- Assigns "Stone" to Dest2
Bounded Length String Copying
-- 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;
Ada Bounded_String type provides a number of functions for dealing with slices.
Unbounded Length String Copying
-- 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;
BASIC
Interpeter: QuickBasic 4.5, PB 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;
Objective-C
Immutable strings - since they are immutable, you may get the same instance with its references count increased.
NSString *original = @"Literal String" NSString *new = [original copy];
Mutable strings - you can get either new mutable or immutable string:
NSMutableString *original = @"Literal String" NSString *immutable = [original copy]; NSMutableString *mutable = [original mutableCopy];
Copying a CString:
char *cstring = "I'm a plain C string"; NSString *string = [NSString stringWithUTF8String:cstring];
Copying from data, possibly not null terminated:
char bytes[] = "some data"; NSString *string = [[NSString alloc] initWithBytes:bytes length:9 encoding:NSASCIIStringEncoding];
And of course, if a C string is needed, you can use standard functions like strcpy.
C++
Libraries: C++ Standard Library
#include <string> std::string src = "Hello"; std::string dst = src;
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;
D
char[] src = "string"; char[] dest = src.dup;
Erlang
Src = "Hello". Dst = Src.
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
Java
String src = "Hello"; String dst = new String(s);
JavaScript
var src = "Hello"; var dst = src;
Lisp
(setf orig "Hello") (setf copied (copy-seq orig))
test the copy: (equalp orig copied) t (eq orig copied) nil
Perl
Interpeter: Perl
my $src = "Hello"; my $dst = $src;
PHP
$src = "Hello"; $dst = $src;
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
Interpeter: Python 2.3, 2.4, 2.5
Since strings are immutable, all copy operations return the same string. Probably the reference is increased.
>>> 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
To actually copy a string:
>>> a = 'hello' >>> b = ''.join(a) >>> a == b True >>> b is a False
Some strings like empty string and single character strings like 'a' still return the same object even with this method.
Ruby
src="Hello" dst=src.dup
Seed7
var string: dest is "";
dest := "Hello";
Tcl
set src "Rosetta Code" set dst $src
Toka
" hello" is-data a a string.clone is-data b