assigning values to an array after declaring it

[Eric Bantock]

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members than the following:

myarray[0]=8;
myarray[1]=3;
myarray[2]=4;
myarray[3]=0;
myarray[4]=0;
myarray[5]=1;
myarray[6]=8;
myarray[7]=8;
etc...

I can't assign values immediately on declaration because I want myarray
to be initialised differently according to various cases only determined
at runtime.

Thanks for any help. best regards -Eric

[Thomas Matthews]

Eric Bantock wrote:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members than the following:

myarray[0]=8;
myarray[1]=3;
myarray[2]=4;
myarray[3]=0;
myarray[4]=0;
myarray[5]=1;
myarray[6]=8;
myarray[7]=8;
etc...

I can't assign values immediately on declaration because I want myarray
to be initialised differently according to various cases only determined
at runtime.

Thanks for any help. best regards -Eric

Here are some ideas:
1. Many constant arrays:
Declare constant arrays for each case in the program.
Copy the data from the constant array to the variable
depending on the circumstances. If the data won't change,
then use a pointer instead of an array.

2. Load data from a stream (file).
Prefer a text file to a binary file. Text files can be
easily created and updated using an editor. Binary files
are more difficult to create and maintain.

3. Load data from another source.
Some platforms have places that programs can store
their data, such as a registry or ROM. Accessing these
are off-topic for this newsgroup and not portable.
--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.l earn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book

[Mark McIntyre]

On Wed, 16 Jun 2004 15:55:26 +0000 (UTC), in comp.lang.c , Eric Bantock
<[e-mail] > wrote:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members

(than assigning values to members)

No.

Well, you could memcpy data into it, if you could be sure of byte order and
alignment constraints.

--
Mark McIntyre
CLC FAQ <http://www.eskimo.com/~scs/C-faq/top.html>
CLC readme: <http://www.angelfire.c om/ms3/bchambless0/welcome_to_clc. html>
----== Posted via Newsfeed.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeed.com The #1 Newsgroup Service in the World! >100,000 Newsgroups
---= 19 East/West-Coast Specialized Servers - Total Privacy via Encryption =---
----== Posted via Newsfeed.Com - Unlimited-Uncensored-Secure Usenet News==----
http://www.newsfeed.com The #1 Newsgroup Service in the World! >100,000 Newsgroups
---= 19 East/West-Coast Specialized Servers - Total Privacy via Encryption =---

[Eric Sosman]

Eric Bantock wrote:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members than the following:

myarray[0]=8;
myarray[1]=3;
myarray[2]=4;
myarray[3]=0;
myarray[4]=0;
myarray[5]=1;
myarray[6]=8;
myarray[7]=8;
etc...

I can't assign values immediately on declaration because I want myarray
to be initialised differently according to various cases only determined
at runtime.

You can use a loop:

for (i = 0; i < N; ++i)
myarray[i] = some_expression _probably_invol ving_i;

Of course, this approach requires that there is some method
behind the apparent madness of 8,3,4,...

If the array contents are not systematic or readily computed
but have been laboriously typed in from historical records of
molybdenum production in nineteenth-century Bolivia *but* there
are only a few such sets of data, you could carry a few pre-
initialized arrays around and then copy the chosen one into
myarray[] at run-time:

const SomeType data_sets[][N] = {
{ 8,3,4, ... },
{ 6,6,8, ... },
{ 4,9,2, ... },
...
};
SomeType myarray[N];
...
int k = index_of_chosen _data_set;
memcpy(myarray, data_sets[k], sizeof myarray);

It's hard to recommend one approach over the other (or
over alternative possibilities) without some notion of what
you're really trying to accomplish.

--
Er*********@sun .com

[Dan Pop]

In <ca**********@u s23.unix.fas.ha rvard.edu> Eric Bantock <[e-mail] > writes:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members than the following:

myarray[0]=8;
myarray[1]=3;
myarray[2]=4;
myarray[3]=0;
myarray[4]=0;
myarray[5]=1;
myarray[6]=8;
myarray[7]=8;
etc...

I can't assign values immediately on declaration because I want myarray
to be initialised differently according to various cases only determined
at runtime.

If there are only a few possibilities, create an array for each one:

static const int ini1[] = { ... };
static const int ini2[] = { ... };
static const int ini3[] = { ... };

Then, if you have decided that ini2 is the right initialiser, you can do:

memcpy(myarray, ini2, sizeof myarray);

The other solution is a compound literal, but since this works in C99 only
I'm not advising it.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Peter Ammon]

Eric Bantock wrote:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members than the following:

myarray[0]=8;
myarray[1]=3;
myarray[2]=4;
myarray[3]=0;
myarray[4]=0;
myarray[5]=1;
myarray[6]=8;
myarray[7]=8;
etc...

I can't assign values immediately on declaration because I want myarray
to be initialised differently according to various cases only determined
at runtime.

Thanks for any help. best regards -Eric

Initializers can be determined at runtime. Why can't you initialize
where you define it? You can use an inner scope.

void foo(void) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
{
float arr[] = {a, b, c};
/* do something with arr */
}
}

[nobody]

"Mark McIntyre" <ma**********@s pamcop.net> wrote in message
news:2u******** *************** *********@4ax.c om...

On Wed, 16 Jun 2004 15:55:26 +0000 (UTC), in comp.lang.c , Eric Bantock
<[e-mail] > wrote:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members (than assigning values to members)

No.

Well, you could memcpy data into it, if you could be sure of byte order

and alignment constraints.

But that wouldn't be *assigning* (as in "assigning values to its members"),
would it? IMHO, as usual, problem lies in
the problem definition, which seems not to define the problem, but to imply
the solution., and question turns out to be about the implementation of
particular
"suggested" solution. I hate it when my bosses are doing this to me. So the
1st
answer is perfectly correct (to my limited knowledge). Second one will
hopefully
clarify OP's question to himself. Though it may be considered irritating to
some participants here, I go by the old Chinese proverb: "Give a man a fish
and
you feed him for a day. Teach a man to fish, and you feed him for a
lifetime..",
even if someone only asks for one (topical) fish, (non-topical) reply in
some
circumstances can be more beneficial, in the long run.

[Neil Kurzman]

Eric Bantock wrote:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members than the following:

myarray[0]=8;
myarray[1]=3;
myarray[2]=4;
myarray[3]=0;
myarray[4]=0;
myarray[5]=1;
myarray[6]=8;
myarray[7]=8;
etc...

I can't assign values immediately on declaration because I want myarray
to be initialised differently according to various cases only determined
at runtime.

Thanks for any help. best regards -Eric

suggestion 1
create the other constant arrays. Then assign each value in a for loop
or with memcopy();

suggestion 2
create all the possible arrays, then use a pointer to choose the correct
one.

[Dan Pop]

In <2u************ *************** *****@4ax.com> Mark McIntyre <ma**********@s pamcop.net> writes:

On Wed, 16 Jun 2004 15:55:26 +0000 (UTC), in comp.lang.c , Eric Bantock
<[e-mail] m> wrote:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members(than assigning values to members)

No.

When Mark McIntyre says "no", it is usually safe to assume that the answer
is "yes". And vice versa.
Well, you could memcpy data into it, if you could be sure of byte order and ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^alignment constraints.

^^^^^^^^^^^^^^^ ^^^^^^

An idiotic statement, as one could expect from Mark. Since the
initialiser is compiled by the same compiler, there are no representation
issues at all. And memcpy() has NO alignment constraints: it is
actually the right way of handling assignments when the source is not
guaranteed to be aligned for its type (but this is a non-issue here,
anyway).

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Eric Bantock]

Eric Sosman <Er*********@su n.com> wrote:

Eric Bantock wrote:

Very basic question I'm afraid. Once an array has been declared, is there
a less tedious way of assigning values to its members than the following:

[snip] You can use a loop: for (i = 0; i < N; ++i)
myarray[i] = some_expression _probably_invol ving_i; Of course, this approach requires that there is some method
behind the apparent madness of 8,3,4,...
yes, and in this case unfortunately there is none.
const SomeType data_sets[][N] = {
{ 8,3,4, ... },
{ 6,6,8, ... },
{ 4,9,2, ... },
...
};
SomeType myarray[N];
...
int k = index_of_chosen _data_set;
memcpy(myarray, data_sets[k], sizeof myarray);

Thanks Eric (and Dan and others who suggested a similar approach) - this
is what I'll do. Actually, I have always wondered (but never been curious
enough to actually find out) exactly *why* C won't let you assign values
"all at once" to an array except at declaration. Can anyone explain?

Eric