Here goes:

main()
{
   void foo(char *);
   char MyArray[2][50];
   char *ptrMyArray;

   ptrMyArray = MyArray;         generates "suspicious pointer conversion"

                        foo(ptrMyArray);

void foo(char *)
{
. . .

I give up. Also, I had to modify the orginal code so that foo
accepted a pointer variable instead of a pointer constant. I would
prefer to pass foo MyArray (a pointer constant) instead of
ptrMyArray (a pointer variable).

--
email:

fax:
(404)494-3182

Hello

This is a two dimensional array.  If you think about it in terms of pointers, what
does *(Myarray+1) equal??

This is a one dimensional array.  What does *(ptrMyArray+1) equal??

The first is a char *.

The second in a char

It should this is not doing what you want!
You want ptrMyArray to be a char **.

Soren Dayton

 Hi,

 I am trying to allocate memory for a pointer to an array of NCOL chars.
 According to the FAQ the following should work:

   #define NCOL 10

   int main ()
   {
      int  NROWS = 10;
      char (*pa)[NCOL];   /* pa is pointer to char array of size NCOL */

      pa = (char (*)[NCOL]) malloc (NROWS * sizeof (*pa));

      /* other statements */
   }

 I get no compilation errors or warnings for this code fragment using either
 cc or gcc under Ultrix on a Dec5000, but when I try to inspect the size of
 (*pa), I get an answer of 40. On my machine, sizeof(char) == 1. Shouldn't
 I get an answer of 10, or am I missing something?

 Something else: once I have allocated memory for pa, what is the proper
 way of reading in values? Would  strcpy(pa[i],string) work?  

 Please enlighten me on the above subjects. Thanks in advance,

 Nikolas.

It depends exactly what you want to do but the pointer conversion is
suspicious, no doubt about it.

        char Array[20];         /* Defines an array     */
        char (*ArrayPtr)[];     /* Defines a pointer    */

        Array[2] = 'a';
        ArrayPtr = &Array;

        printf("%c\n", ((*ArrayPtr)[2]));

With two dimensional arrays the compiler must know the size of the dimensions
in order to dereference the arrays, in the above example there is no need
to specify it (i.e. I used [] in the ArrayPtr definition) even so it works
in the same way.

Keith

That's because MyArray can be assigned to a pointer to arrays
of 50 chars with no problem, but not to a pointer to char.

So, if you declare ptrMyArray as:

    char (* ptrMyArray)[ 50 ];

the problem will go away. foo() could be declared as

    void foo( char (*)[ 50 ] );

    foo(MyArray);

Try

#include <stdio.h>

void foo( char (* const p)[50] )
{
        printf( "%c\n", p[1][49] );

int main( void )
{
        char aach[ 2 ][ 50 ];

        aach[1][49] = 'O';
        foo( aach );
        return 0;

--
| Kurt Watzka                             Phone : +49-89-2180-2158

   Here goes:

   main()
   {
      void foo(char *);
      char MyArray[2][50];
      char *ptrMyArray;

      ptrMyArray = MyArray;         generates "suspicious pointer conversion"

                           foo(ptrMyArray);
   }

   void foo(char *)
   {
   . . .
   }

The problem is that MyArray is not really a char *.  It is
a char (*)[50], that is, a pointer to an array of 50
characters.  You should either change foo() to accept char (*)[50],
or change MyArray to char [100].

Ed Karrels

It is.  'MyArray' is char[][], which can decay into 'char **' in expressions.
'ptrMyArray' is char[], which can decay into 'char *' in expressions.

'MyArray' as declared is an array of objects of type array of char, i.e.,
it's a (nearly, though technically not) multi-dimensional array.  This
is not legitimately equivalent to a 'char *'.  Try 'ptrMyArray = MyArray[0];'
and see if that helps.

-seebs
--

GAT(CS/M/P/SS) d-- H++ s+: !g p? !au a- w+++ v+++/* C++++ UB/V++++ P+ L b+++ !D
3+(NetBSD/Amiga) E- N+++ K !W--- M++/-- V- -po+ Y+ t 5++ jx R G'''' tv- B---
e++ u** h--- f+ r+++ !n x+++*   --SeebS-- / The Laughing Prophet

MyArray can not decay into char **.  If you have a C compiler which converts
char [][50] into a char **, get rid if it.  In most expressions, MyArray
will be automatically converted into a char (*)[50].

--
Mike Rubenstein