Re: How to retrieve data from array of pointers or from a struct?

[Keith Thompson]

Victor <vh*******@yahoo.comwrites:

I have 2 problems:

First, I want to grep one pattern at a time from the pattern group
below:

unsigned long long i;

unsigned long long *dataPatternPtr[] = {
0xa0a00000000000aaLL,

[...]

0xABCDEF0123456789LL,
};

You're declaring an array of pointers to unsigned long long, but
you're initializing the pointers with integer values. This is
actually a constraint violation, and your compiler should have warned
you about it. Your problem is either that you're invoking your
compiler in some non-standard mode that inhibits the warnings, or
getting warnings and not bothering to tell us about them.

What are you actually trying to do? Do you want an array of integers
or an array of pointers?

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Victor]

On Nov 9, 9:21*am, Keith Thompson <[e-mail]:

Victor <[e-mail]:

I have 2 problems:

First, I want to grep one pattern at a time from the pattern group
below:

unsigned long long i;

unsigned long long *dataPatternPtr[] = {
* * 0xa0a00000000000aaLL,

[...]

* * 0xABCDEF0123456789LL,
* };

You're declaring an array of pointers to unsigned long long, but
you're initializing the pointers with integer values. *This is
actually a constraint violation, and your compiler should have warned
you about it. *Your problem is either that you're invoking your
compiler in some non-standard mode that inhibits the warnings, or
getting warnings and not bothering to tell us about them.

What are you actually trying to do? *Do you want an array of integers
or an array of pointers?

--
Keith Thompson (The_Other_Keith) [e-mail] *<http://www.ghoti.net/~kst>
Nokia
"We must do something. *This is something. *Therefore, we must do this."
* * -- Antony Jay and Jonathan Lynn, "Yes Minister"

Hi,

I modified my script to use an array of longs instead of array of
pointers to longs:

unsigned long long dataPatternArray[] = {
0xa0a00000000000aaLL,
0xFFFFFFFFFFFFFFFFLL,
0x5555555555555555LL,
0xAAAAAAAAAAAAAAAALL,
0xCCCCCCCCCCCCCCCCLL,
0x3333333333333333LL,
0xEEEEEEEEEEEEEEEELL,
0x7777777777777777LL,
0x0000000000000001LL,
0xFFFFFFFFFFFFFFFELL,
0xABCDEF0123456789LL,
};

Again, I can successfully access my elements via:

dataPatternArray[0]
dataPatternArray[1]
dataPatternArray[2]
....
dataPatternArray[7]

and so on.

However if I use a variable "i" in a "for" loop to access each of
them:

for (i=0; i <= MAX; i++) {
printf("Pattern = %08x\n", (int *)dataPatternArray[i]);
}

Then the above WON'T WORK because of compile error: undefined
reference to `memcpy
However if I simply hardcode value for "i" like in the following, then
it works. Any idea?

for (i=0; i <= MAX; i++) {
i = 7;
printf("Pattern = %08x\n", (int *)dataPatternArray[i]);
}

Bottom line is I need to CYCLE THRU all patterns to retrieve them.
Why doesn't it work?

Thanks,
Victor

[Keith Thompson]

Victor <vh*******@yahoo.comwrites:

On Nov 9, 9:21*am, Keith Thompson <[e-mail]:

>Victor <[e-mail]:

I have 2 problems:

First, I want to grep one pattern at a time from the pattern group
below:

unsigned long long i;

unsigned long long *dataPatternPtr[] = {
* * 0xa0a00000000000aaLL,

[...]

* * 0xABCDEF0123456789LL,
* };

You're declaring an array of pointers to unsigned long long, but
you're initializing the pointers with integer values. *This is
actually a constraint violation, and your compiler should have warned
you about it. *Your problem is either that you're invoking your
compiler in some non-standard mode that inhibits the warnings, or
getting warnings and not bothering to tell us about them.

What are you actually trying to do? *Do you want an array of integers
or an array of pointers?

Please don't quote signatures.

I modified my script to use an array of longs instead of array of
pointers to longs:

It's a program, not a script.

unsigned long long dataPatternArray[] = {
0xa0a00000000000aaLL,
0xFFFFFFFFFFFFFFFFLL,
0x5555555555555555LL,
0xAAAAAAAAAAAAAAAALL,
0xCCCCCCCCCCCCCCCCLL,
0x3333333333333333LL,
0xEEEEEEEEEEEEEEEELL,
0x7777777777777777LL,
0x0000000000000001LL,
0xFFFFFFFFFFFFFFFELL,
0xABCDEF0123456789LL,
};

Ok.

Again, I can successfully access my elements via:

dataPatternArray[0]
dataPatternArray[1]
dataPatternArray[2]
...
dataPatternArray[7]

and so on.

However if I use a variable "i" in a "for" loop to access each of
them:

for (i=0; i <= MAX; i++) {
printf("Pattern = %08x\n", (int *)dataPatternArray[i]);
}

You're taking dataPatternArray[i], a value of type unsigned long long,
and converting it to int* (pointer to int). This makes no sense.
You're then printing this pointer value using a "%08x" format; "%x" or
"%08x" is for printing a value of type unsigned int, not int*. (And
you're specifying at least 8 digits, but your values are 16 digits.)

Previously, you showed a declaration of i as an unsigned long long.
This isn't wrong, but since i is an index into the array, which has
only a few elements, it would make more sense to declare it as an int.

You're looping from 0 to MAX. What is MAX? If it's the number of
elements in the array, then you're going past the end of the array.
(That's not related to the symptoms you're describing.)

The way to print a value of type unsigned long long in hexadecimal is:

for (i = 0; i < MAX; i++) {
printf("Pattern = %016llx\n", dataPatternArray[i]);
}

Then the above WON'T WORK because of compile error: undefined
reference to `memcpy

You're not explicitly calling memcpy, but it's possible that your
compiler is implicitly calling memcpy to copy the value, perhaps
because the CPU doesn't have a native instruction to copy a 64-bit
value. memcpy is part of the standard library, and most
implementations will link it automatically, so you don't have to do
anything special to make memcpy available -- but apparently either
your implementation doesn't do that, or you're invoking it
incorrectly, or it's configured incorrectly. I don't think you've
told us what compiler you're using, but you should be able to find a
forum that discusses it. Write a complete self-contained program that
illustrates your problem (not the code fragments you've been posting
here) and post it either here or in a support form for your compiler.
We need something we can compile and run ourselves; if you don't know
what the problem is, you don't know what you can safely leave out. We
can help you with any C language issues, but we can't help you with
any problems you're having with your compiler.

[...]

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Martin Ambuhl]

Victor wrote:

However if I use a variable "i" in a "for" loop to access each of
them:

for (i=0; i <= MAX; i++) {
printf("Pattern = %08x\n", (int *)dataPatternArray[i]);
}

Then the above WON'T WORK because of compile error: undefined
reference to `memcpy

I don't believe you. And your code is random nonsense.

However if I simply hardcode value for "i" like in the following, then
it works. Any idea?

for (i=0; i <= MAX; i++) {
i = 7;
printf("Pattern = %08x\n", (int *)dataPatternArray[i]);
}

Bottom line is I need to CYCLE THRU all patterns to retrieve them.
Why doesn't it work?

Because you haven't bothered to learn even the most basic aspects of C.

/* mha: _Please_ post the real code. Your messages are really a mess.
* Your problem is not reproduceable, simply because you have hidden
* your error by snipping it away. Your description of your problem is
* absurd: by "diagnosing" it yourself, you have only fooled yourself.
* If the following compiles and runs, then you are completely wrong
* about what is happening. And your attempt at a printf statement
* looks like random typing. */

#include <stdio.h>

#define MAX (sizeof dataPatternArray/sizeof *dataPatternArray)

int main(void)
{
unsigned long long dataPatternArray[] = {
0xa0a00000000000aaLL,
0xFFFFFFFFFFFFFFFFLL,
0x5555555555555555LL,
0xAAAAAAAAAAAAAAAALL,
0xCCCCCCCCCCCCCCCCLL,
0x3333333333333333LL,
0xEEEEEEEEEEEEEEEELL,
0x7777777777777777LL,
0x0000000000000001LL,
0xFFFFFFFFFFFFFFFELL,
0xABCDEF0123456789LL,
};
size_t i;

/* mha: note that the following has "i < MAX" instead of your "i <=
MAX". Since you have refused to tell us your definition for MAX,
we can only guess. My definition is above.

Note also that the specifier for a unsigned long long in hex is
not "%08x", and (int *)dataPatternArray[i] is just nonsense. If
you really wanted a pointer to print, the specifier is "%p" and
the cast is to (void *) */
for (i = 0; i < MAX; i++)
printf("Address of Pattern = %p, "
"Pattern = %#08llx\n", (void *) &dataPatternArray[i],
dataPatternArray[i]);
return 0;
}

[output]
Address of Pattern = dff50, Pattern = 0xa0a00000000000aa
Address of Pattern = dff58, Pattern = 0xffffffffffffffff
Address of Pattern = dff60, Pattern = 0x5555555555555555
Address of Pattern = dff68, Pattern = 0xaaaaaaaaaaaaaaaa
Address of Pattern = dff70, Pattern = 0xcccccccccccccccc
Address of Pattern = dff78, Pattern = 0x3333333333333333
Address of Pattern = dff80, Pattern = 0xeeeeeeeeeeeeeeee
Address of Pattern = dff88, Pattern = 0x7777777777777777
Address of Pattern = dff90, Pattern = 0x000001
Address of Pattern = dff98, Pattern = 0xfffffffffffffffe
Address of Pattern = dffa0, Pattern = 0xabcdef0123456789