Thread: c identifier error

#include <stdlib.h>?

remove ?

Code:

#define argc __argc
#define argv __argv
  return mclRunMain(run_main, argc, argv);

converts to
return mclRunMain(run_main, __argc, __argv);

but vars __argc, __argv are not defined

Code:

#define argc __argc
#define argv __argv
  return mclRunMain(run_main, argc, argv);

converts to

Code:

return mclRunMain(run_main, __argc, __argv);

but vars __argc, __argv are not defined

I think MSVC declares __argc and __argv when using WinMain(), which is presumably what this code is trying to take advantage of. However, perhaps this only happens in console mode or something? It would seem this way. http://www.knakkergaard.dk/troels/code.htm

__argc, __argv

Code:

#ifdef _MSDOS
extern int    __argc;
extern TCHAR** __argv;

#endif __argc and __argv isn't prototyped anywhere in antiquated Microsoft compilers. They're practical to have in scope, also outside of main().

So -- try compiling the code as a console program, not as a Windows one.

Code:

int main(int argc, const char **argv)

Do not make argv const. For reasons I don't feel like explaining, const pointers-to-pointers are asking for trouble. Besides, main() is prototyped as

Code:

int main(int, char **);

No const there.

Originally Posted by dwks

Code:

int main(int argc, const char **argv)

Do not make argv const. For reasons I don't feel like explaining, const pointers-to-pointers are asking for trouble. Besides, main() is prototyped as

Code:

int main(int, char **);

No const there.

I'm curious whenever you may find the time.

Originally Posted by Dave_Sinkula

I'm curious whenever you may find the time.

Uogh! It took me some time to get what you are asking for

Looks like it came up before but no one knew anything about it: http://cboard.cprogramming.com/showthread.php?t=83918 (post 42 onwards)

Unfortunately, I can't remember why myself. I wish I could dig up the book that mentioned why it's not allowed, but I can't find it at the moment.

I'll keep looking, but I don't think I'll find anything.

It's possible that I misread or misremembered the passage. It's only the one book I've ever seen it mentioned in.

Aha! I found it! http://c-faq.com/ansi/constmismatch.html
(Via this thread: http://www.velocityreviews.com/forum...nter-type.html)

The book I was talking about was C++ Primer Plus, probably 4th edition. There's an online version of it, but unfortunately I think the page I was looking for was page 269, which isn't part of the preview. Still, there is some circumstantial evidence on page 271. http://books.google.ca/books?id=zuyA...NgTs#PPA271,M1

Using const in that declaration means that show_array() cannot alter the values in any array passed to it. This technique works as long as there is just one level of indirection. Here, for example, the array elements are a fundamental type. But if they were pointers or pointers-to-pointers, you wouldn't use const.

(Note: I transcribed that paragraph out, because my browser won't let me copy-and-paste it. There might be an error or two in it.)

But the FAQ is best of all. Enjoy. I'm still trying to understand it myself . . . .

you can always use
const char* const* ppArr;

or you mean something else?

Thanks dwk. Would I be correct in saying that the issue with main mainly has to do with main being a special case?

I don't think so. Here's why.

Code:

$ cat star.c
#include <stdio.h>

int main() {
    char **noconst = 0;
    const char **p = noconst;
    return 0;
}
$ gcc -W -Wall -ansi -pedantic -g star.c -o star
star.c: In function `main':
star.c:5: warning: initialization from incompatible pointer type
star.c:5: warning: unused variable `p'
$

You cannot assign a char ** to a const char **. The FAQ I linked to explains why. Therefore, any function that is passed a char ** cannot be prototyped or defined to take a const char **. This is not a case special to main(). You cannot do this. The FAQ explains why better than I ever could.

you can always use

Code:

const char* const* ppArr;

or you mean something else?

Nope . . .

Code:

$ cat star.c
#include <stdio.h>

int main() {
    char **noconst = 0;
    const char *const *const p = noconst;
    return 0;
}
$ gcc -W -Wall -ansi -pedantic -g star.c -o star
star.c: In function `main':
star.c:5: warning: initialization from incompatible pointer type
star.c:5: warning: unused variable `p'
$ # however, it does work as C++
$ cp star.c star.cpp
$ g++ -W -Wall -ansi -pedantic -g star.cpp -o star
star.cpp: In function `int main()':
star.cpp:5: warning: unused variable `const char* const* const p'
$

This is all explained in the FAQ I linked to.

(C++ has more complicated rules for assigning const-qualified pointers which let you make more kinds of assignments without incurring warnings, but still protect against inadvertent attempts to modify const values. C++ would still not allow assigning a char ** to a const char **, but it would let you get away with assigning a char ** to a const char * const *.)

I suggest you read it. It's interesting, really.

Originally Posted by dwks

I suggest you read it. It's interesting, really.

I did look at the FAQ and some of these. My use of "special" is that other functions, being user defined, could further qualify the arguments. But since main is not specified any further qualified, such an option is off the table.

Yes, it seems you're right. main() is a special case.

The thing is, I thought that const pointers-to-pointers were always a bad idea, not just when you tried to convert them to non-const pointers in various combinations . . .

So what did you discover after reading that 52-message thread? Or one of the other ones . . . .