Multiple distinct objects: Difference between revisions

Create a [[sequence]] (array, list, whatever) consisting of <var>n</var> distinct, initialized items of the same type. <var>n</var> should be determined at runtime.

 

 

See also: [[Closures/Value capture]]

 

=={{header|Ada}}==

Here N can be unknown until run-time. T is any constrained type. In [[Ada]] all objects are always initialized, though some types may have null initialization. When T requires a non-null initialization, it is done for each array element. For example, when T is a [[task]] type, N tasks start upon initialization of A. Note that T can be a ''limited'' type like task. Limited types do not have predefined copy operation. Arrays of non-limited types can also be initialized by aggregates of:

Here V is some value or expression of the type T. As an expression V may have side effects, in that case it is evaluated exactly N times, though the order of evaluation is not defined. Also an aggregate itself can be considered as a solution of the task:

 

=={{header|Aime}}==

show_sublist(list l)

{

 

}

}

{

integer i;

 

o_text(" [");

o_text("]");

}

 

list l;

 

 

return l;

 

# modify one of the sublists

 

# display the list of lists

 

return 0;

{{out}}

<pre> [4] [4] [4] [7] [4] [4] [4] [4]</pre>

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

INT n := 26;

[n]FOO f;

FOR i TO UPB f DO f[i] := (REPR(ABS("A")-1+i), REPR(ABS("a")-1+i)) OD;

 

Output:

<pre>

</pre>

 

 

=={{header|AppleScript}}==

 

end nObjects

 

on run

end script

 

set d to -1

else

end repeat

return lst

 

 

{{Out}}

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

Loop, %n%

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

n% = RND(1000)

FOR i% = 0 TO DIM(objects%(),1)

objects%(i%) = object{}

 

=={{header|Brat}}==

The wrong way, which creates an array of ''n'' references to the same new ''foo'':

 

 

The right way, which calls the block ''n'' times and creates an array of new ''foo''s:

 

 

=={{header|C}}==

for (int i = 0; i < n; i++)

 

(Or if no particular initialization is needed, skip that part, or use <tt>calloc</tt>.)

 

=={{header|C++}}==

 

Using only language primitives:

T* p = new T[n]; // if T is POD, the objects are uninitialized, otherwise they are default-initialized

 

 

// when you don't need the objects any more, get rid of them

 

Using the standard library

#include <algorithm>

#include <iterator>

// To initialise each value differently

std::generate_n(std::back_inserter(vec), n, makeT); //makeT is a function of type T(void)

 

In C++ reference semantics are achieved by holding objects by pointer. Here is an example of the error, and a correct way of achieving distinctness.

These examples assume T has a public copy constructor, and that p is a pointer to T;

 

#include <tr1/memory>

using namespace std;

bvec2.push_back(TPtr_t(new T(*p));

 

Of course, also in this case one can use the other sequence containers or plain new/delete instead of <tt>vector</tt>.

 

=={{header|Clojure}}==

An example using pseudo-random numbers:

(0.2787011365537204 0.2787011365537204 0.2787011365537204)

user> (take 3 (repeatedly rand)) ; creating three different random number

(0.8334795669220695 0.08405601245793926 0.5795448744634744)

 

=={{header|Common Lisp}}==

The mistake is often written as one of these:

which are incorrect since the form <code>(make-the-distinct-thing)</code> is only evaluated once and the single object is put in every position of the sequence. A commonly used correct version is:

which evaluates <code>(make-the-distinct-thing)</code> <var>n</var> times and collects each result in a list.

 

It is also possible to use <code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_map_in.htm map-into]</code>, the destructive map operation, to do this since it may take zero input sequences; this method can produce any sequence type, such as a vector (array) rather than a list, and takes a function rather than a form to specify the thing created:

 

 

=={{header|D}}==

For reference types (classes):

foreach (ref item; fooArray)

item = new Foo();

 

For value types:

 

=={{header|Delphi}}==

 

Same object accessed multiple times (bad)

i: Integer;

lObject: TMyObject;

for i := 1 to 10 do

lList.Add(lObject);

 

Distinct objects (good)

i: Integer;

lList: TObjectList<TMyObject>;

for i := 1 to 10 do

lList.Add(TMyObject.Create);

 

=={{header|E}}==

[[Category:E examples needing attention]] E needs development of better map/filter/stream facilities. The easiest way to do this so far is with the accumulator syntax, which is officially experimental because we're not satisfied with it as yet.

 

...

 

 

=={{header|EchoLisp}}==

;; wrong - make-vector is evaluated one time - same vector

 

 

L → (#(0 🔵 0 0) #(0 0 0 0) #(0 0 0 0)) ;; OK

 

=={{header|Elixir}}==

 

=={{header|Erlang}}==

Randoms = [random:uniform(1000) || _ <- lists:seq(1,10)].

</pre>

 

=={{header|Factor}}==

clone is the important word here to have distinct objects. This creates an array of arrays.

 

=={{header|Forth}}==

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

 

list each: drop . 1301600

list each: drop . 1301600

 

=={{header|Fortran}}==

 

program multiple

! Define a simple type

 

end program multiple

 

=={{header|Go}}==

Useful:

d2 := make([][]int, n)

for i := range d2 {

}

return d2

Probably not what the programmer wanted:

d1 := make([]int, m)

d2 := make([][]int, n)

}

return d2

 

=={{header|Groovy}}==

 

Correct Solution:

 

Incorrect Solution:

 

Test:

print "Objects distinct for n = "

(2..<20).each { n ->

}

println()

 

Output:

 

Below, we are assuming that <tt>makeTheDistinctThing</tt> is a monadic expression (i.e. it has type <code>m a</code> where <code>m</code> is some monad, like <code>IO</code> or <code>ST</code>), and we are talking about distinctness in the context of the monad. Otherwise, this task is pretty meaningless in Haskell, because Haskell is referentially transparent (so two values that are equal to the same expression are necessarily not distinct) and all values are immutable.

in an appropriate do block. If it is distinguished by, say, a numeric label, one could write

 

An incorrect version:

 

=={{header|Icon}} and {{header|Unicon}}==

An incorrect approach uses, e.g., the list constructor procedure with an initial value:

 

items_wrong := list (10, [])

# prints '0' for size of each item

# now prints '1' for size of each item

every item := !items_wrong do write (*item)

 

A correct approach initialises each element separately:

 

items := list(10)

every i := 1 to 10 do items[i] := []

 

=={{header|J}}==

 

Example use:

 

 

J almost always uses pass-by-value, so this topic is not very relevant to J.

{{works with|Java|1.5+}}

simple array:

for (int i = 0; i < foos.length; i++)

foos[i] = new Foo();

// incorrect version:

Foo[] foos_WRONG = new Foo[n];

 

simple list:

for (int i = 0; i < n; i++)

foos.add(new Foo());

 

// incorrect:

 

Generic version for class given at runtime:

 

It's not pretty but it gets the job done. The first method here is the one that does the work. The second method is a convenience method so that you can pass in a <tt>String</tt> of the class name. When using the second method, be sure to use the full class name (ex: "java.lang.String" for "String"). <tt>InstantiationException</tt>s will be thrown when instantiating classes that you would not normally be able to call <tt>new</tt> on (abstract classes, interfaces, etc.). Also, this only works on classes that have a no-argument constructor, since we are using <code>newInstance()</code>.

List<E> ans = new LinkedList<E>();

try {

throws ClassNotFoundException{

return getNNewObjects(n, Class.forName(className));

 

=={{header|JavaScript}}==

===ES5===

 

for (var i = 0; i < n; i++)

 

 

===ES6===

 

 

let nObjects = n => Array.from({

return nObjects(6);

 

 

 

{{Out}}

 

=={{header|jq}}==

def Array(atype; n):

if atype == "number" then [ range(0;n) ]

# Example:

 

 

=={{header|Logtalk}}==

Using prototypes, we first dynamically create a protocol to declare a predicate and then create ten prototypes implementing that protocol, which one with a different definition for the predicate:

| ?- create_protocol(statep, [], [public(state/1)]),

findall(

).

Ids = [o1, o2, o3, o4, o5, o6, o7, o8, o9, o10].

Using classes, we first dynamically create a class (that is its own metaclass) to declare a predicate (and define a default value for it) and then create ten instances of the class, which one with a different definition for the predicate:

| ?- create_object(state, [instantiates(state)], [public(state/1)], [state(0)]),

findall(

).

Ids = [o1, o2, o3, o4, o5, o6, o7, o8, o9, o10].

 

=={{header|Lua}}==

local table1 = {1,2,3}

 

-- Now we can create a table of independent copies of table1

local copyTab = {}

 

The mistake is often written as:

 

Here Random[] can be any expression that returns a new value which is incorrect since Random[] is only evaluated once. e.g.

A correct version is:

 

which evaluates Random[] each time e.g.

 

=={{header|Maxima}}==

 

b: makelist(copy(a), 3);

 

b;

 

=={{header|Modula-3}}==

Similar to the [[Ada]] version above:

 

 

=={{header|NGS}}==

 

Incorrect, same object n times:

 

Correct:

 

=={{header|Nim}}==

 

 

 

 

=={{header|OCaml}}==

 

Incorrect:

(* here (new foo) can be any expression that returns a new object,

which is incorrect since <code>new foo</code> is only evaluated once. A correct version is:

 

=={{header|Oforth}}==

The right way : the block sent as parameter is performed n times :

 

 

{{out}}

The "wrong" way : the same value is stored n times into the list buffer

 

 

{{out}}

 

=={{header|ooRexx}}==

array = fillArrayWith(3, .directory)

say "each object will have a different identityHash"

say

loop d over array

end

 

end

 

 

 

=={{header|Oz}}==

With lists, it is difficult to do wrong.

Xs = {MakeList 5} %% a list of 5 unbound variables

in

{ForAll Xs OS.rand} %% fill it with random numbers (CORRECT)

 

With arrays on the other hand, it is easy to get wrong:

Arr = {Array.new 0 10 {OS.rand}} %% WRONG: contains ten times the same number

in

for I in {Array.low Arr}..{Array.high Arr} do

Arr.I := {OS.rand}

 

=={{header|Pascal}}==

=={{header|Perl}}==

incorrect:

# here Foo->new can be any expression that returns a reference representing

which is incorrect since <code>Foo->new</code> is only evaluated once.

 

A correct version is:

which evaluates <tt>Foo->new</tt> <var>$n</var> times and collects each result in a list.

 

 

 

=={{header|PicoLisp}}==

Create 5 distinct (empty) objects:

Create 5 anonymous symbols with the values 1 .. 5:

-> ($384721107 $384721109 $384721111 $384721113 $384721115)

: (val (car @))

-> 1

: (val (cadr @@))

 

=={{header|PowerShell}}==

Do some randomization that could easily return three equal values (but each value is a separate value in the array):

1..3 | ForEach-Object {((Get-Date -Hour ($_ + (1..4 | Get-Random))).AddDays($_ + (1..4 | Get-Random)))} |

Select-Object -Unique |

ForEach-Object {$_.ToString()}

{{Out}}

<pre>

</pre>

Run the same commands a few times and the <code>Select-Object -Unique</code> command filters equal (but separate values):

1..3 | ForEach-Object {((Get-Date -Hour ($_ + (1..4 | Get-Random))).AddDays($_ + (1..4 | Get-Random)))} |

Select-Object -Unique |

ForEach-Object {$_.ToString()}

{{Out}}

<pre>

 

=={{header|PureBasic}}==

Dim A.i(n)

; Creates a Array of n [25-75] elements depending on the outcome of Random().

Next

; Verify by sending each value of A() via *PointersToA()

 

=={{header|Python}}==

The mistake is often written as:

which is incorrect since <tt>Foo()</tt> is only evaluated once. A common correct version is:

which evaluates <tt>Foo()</tt> <var>n</var> times and collects each result in a list. This last form is also discussed [[Two-dimensional array (runtime)#Python|here]], on the correct construction of a two dimensional array.

 

=={{header|R}}==

The mistake is often written as:

A common correct version is:

which evaluates foo() n times and collects each result in a list. (Using simplify=TRUE lets the function return an array, where possible.)

 

=={{header|Racket}}==

 

#lang racket

 

;; a list of 10 distinct vectors

(build-list 10 (λ (n) (make-vector 10 0)))

 

=={{header|Ruby}}==

The mistake is often written as one of these:

which are incorrect since <code>Foo.new</code> is only evaluated once, and thus you now have <var>n</var> references to the ''same'' object. A common correct version is:

which evaluates <code>Foo.new</code> <var>n</var> times and collects each result in an Array. This last form is also discussed [[Two-dimensional array (runtime)#Ruby|here]], on the correct construction of a two dimensional array.

 

=={{header|Scala}}==

if created with the same constructor arguments.

 

 

=={{header|Seed7}}==

The [http://seed7.sourceforge.net/libraries/array.htm#%28in_integer%29times%28in_baseType%29 times] operator creates a new array value with a specified size.

Finally multiple distinct objects are assigned to the array elements.

 

const func array file: openFiles (in array string: fileNames) is func

begin

files := openFiles([] ("abc.txt", "def.txt", "ghi.txt", "jkl.txt"));

 

=={{header|Sidef}}==

 

=={{header|Smalltalk}}==

 

"Create an ordered collection that will grow while we add elements"

c := OrderedCollection new.

1 to: 9 do: [ :i | (c at: i) at: 4 put: i ].

"show it"

 

=={{header|Swift}}==

 

var foos = [Foo]()

 

// incorrect version:

 

=={{header|Tcl}}==

 

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

 

# The class that we want to make unique instances of

for {set i 0} {$i<$n} {incr i} {

lappend theList [$theClass new]

 

=={{header|XPL0}}==

char A; int N, I;

[N:= IntIn(8); \get number of items from command line

for I:= 0 to N-1 do A(I):= I*3; \initialize items with different values

for I:= 0 to N-1 do A:= I*3; \error: "references to the same mutable object"

 

=={{header|zkl}}==

The pump and partial application methods are useful tools for creating initialized lists.

n.pump(List) //-->L(0,1,2)

 

class C{ var n; fcn init(x){n=x} }

n.pump(List,C) //--> L(C,C,C)