By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
455,433 Members | 1,827 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 455,433 IT Pros & Developers. It's quick & easy.

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

P: n/a
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"
Nov 9 '08 #1
Share this Question
Share on Google+
3 Replies


P: n/a
On Nov 9, 9:21*am, Keith Thompson <ks...@mib.orgwrote:
Victor <vhnguy...@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"
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
Nov 9 '08 #2

P: n/a
Victor <vh*******@yahoo.comwrites:
On Nov 9, 9:21*am, Keith Thompson <ks...@mib.orgwrote:
>Victor <vhnguy...@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?
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"
Nov 9 '08 #3

P: n/a
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
Nov 10 '08 #4

This discussion thread is closed

Replies have been disabled for this discussion.