Printable View
Re the two queries above. I would be grateful for some help / explanation. Thank you.Code:int main()
{
// some code
char select[] = makeSelection(); // invalid initializer
puts(select);
// some code
return 0;
}
const char * makeSelection() // don't understand the const * char
{
//some code
gets(choice);
return choice;
}
In C, you need to declare the prototype of the function (or define it altogether) before you use it. The prototype is just the function without the body, like this:
A "char*" is a pointer to "char". A "const char*" is a pointer to "const char".Code:// Do this before main
const char * makeSelection();
I'd like to mention a couple of things you didn't ask about
1) All functions that take no parameters should be declared/defined using "(void)", like this:
because, in C in particular, an empty parameter list doesn't mean it takes no arguments. Strange, I know, but so it is.Code:const char* makeSelection(void);
2) Do not use "gets()". Why gets() is bad / Buffer Overflows - Cprogramming.com
--------------------------------------------------------------------------Quote:
Originally Posted by GReaper
I did declare the function. Have now added "void" though.
I am still getting the same errors.
You didn't declare the prototype! @GReaper was clear in his first line:Quote:
Originally Posted by zach
The words "prototype" and "before" are big hints!Quote:
Originally Posted by GReaper
You will get the same errors because your code is wrong: Assigning a pointer to an incomplete array is wrong and fail to declare a variable (choice)...
And remember that you can't return a pointer to a variable that is local to some function. How is "choice" defined, it's not a "const" since you're trying to get a value from the user so I question your return type as well.
It would be helpful if you posted a small complete program that illustrates the problem, instead of just a couple of meaningless snippets.
---------------------------------------------Quote:
Originally Posted by jimblumberg
This is the code (write() is defined in prelims.h)
Code:#include "prelims.h"
#include <stdio.h>
#include <stdlib.h>
#include<conio.h>
struct about
{
char name[35];
char actionCode[2];
};
int dataEntry();
const char * makeSelection(void);
char choice[5];
int main()
{
prelims();
char select[] = makeSelection(); // error line
write(0,0,select);
dataEntry();
return 0;
}
int dataEntry()
{
struct about data;
gotoxy(0,0);
printf("Concerns : ");
gets(data.name);
char *p;
if ( (p=strchr(data.name,'\n')) != NULL ) *p = '\0';
printf("Action Code : ");
gets(data.actionCode);
if ( (p=strchr(data.actionCode,'\n')) != NULL ) *p = '\0';
FILE *fptr;
fptr=fopen("K:\\descrip", "a+");
fwrite(&data, sizeof(struct about), 1, fptr);
fclose(fptr);
return 0;
}
const char * makeSelection() // read this how to do it but dont understand why
{
gotoxy(0,25);
char line [173];
puts(memset(line,196,172));
write(5,27,"What would you like to do?");
write(5,28,"Enter a description = 1 ");
gets(choice);
return choice;
}
So, why didn't you post that code as well? You do know that you should not have executable code inside a header file, correct?Quote:
---------------------------------------------
This is the code (write() is defined in prelims.h)
Why are you still using gets()? That dangerous function can never be used safely and has actually been removed from the language with the current standard.
Why are your functions still defined with no parameters? Why is choice a global variable? Why not just pass that variable to the function, along with it's size:
So many other problems, fix the above issues then we can address the rest.Code:void makeSelection(char *choice, size_t length);
The why's are because I started to look at C a short while ago, so there is little I know. I worked through a tutorial and took notes. Tutorials don't cover the stuff I was up against in the code referred to. No, I don't know about executable code not belonging inside a header. Why do I still have gets()? Because I first wanted to address the errors the compiler is reporting before polishing up the code.
I'd please like to ask for an explanation of size_t length.
Jim Bluberg asked to see the prelims.h code. Here it is:
Code:#ifndef temp
#define temp
extern void prelims(void);
extern void gotoxy(short x, short y);
extern void write (short a, short b, char words[]);
#endif
#include<windows.h>
#include<conio.h>
#include<stdio.h>
void prelims(void)
{
HANDLE handle;
handle = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(handle,14);
CONSOLE_SCREEN_BUFFER_INFO info;GetConsoleScreenBufferInfo(handle, &info);
COORD new_size =
{
info.srWindow.Right - info.srWindow.Left + 1,
info.srWindow.Bottom - info.srWindow.Top + 1
};
SetConsoleScreenBufferSize(handle, new_size);
HWND wh = GetConsoleWindow();
MoveWindow(wh, 0, 0, 1280, 670,TRUE);
}
extern void gotoxy(short x, short y)
{
COORD pos = {x, y};
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}
extern void write (short a, short b, char words[])
{
gotoxy(a,b);
puts(words);
}
Okay so everything other than the first 4 or 5 lines should be in another c source file, not inside that header (from the #ifndef till the #endif stay in the header).
What do you need to know? Did you try to use your favourite search engine to look up "size_t", if that's what you don't understand?Quote:
I'd please like to ask for an explanation of size_t length.
In this case that is a really poor reason. The gets() function is a big part of your problems and should be fixed now.Quote:
Why do I still have gets()? Because I first wanted to address the errors the compiler is reporting before polishing up the code.
The errors are probably being caused because you are trying to "initialize" an array of char with a pointer being returned from the function, you can't do that.
Stop using the global variables and learn to properly pass values back and forth to your functions as required.
By the way if you were using a modern C compiler compiling to the current C standard you would be getting many more errors than the few you seem to be worrying about. If your going to try to learn C you should be learning modern C (C99 or preferably C11) not the outdated C90 that you appear to be using with your outdated compiler (Visual C doesn't fully support anything other than C90).
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Quote:
Originally Posted by jimblumberg
I am using DEV-C (I also tried Pelle C but the libraries were limited)
I will polish up prelims as you say
I removed gets() from the code and am back in the situation where I input data. name and the code flips on without allowing for the next entry.
I was trying scanf() instead of gets() because the suggested alternative for gets() freaked.
Show what you tried? The fgets() function should be the "replacement". However you need to insure that you array is big enough to hold both the end of string character and the end of line character that fgets() adds to the string.
I would be willing to bet that you're overflowing your arrays with your input. Did you limit the number of characters scanf() will try to retrieve into your string, if not then you're no better off than using gets(). You need to use a function that limits the number of characters it will try to retrieve to "eliminate" buffer overflow problems.Quote:
I removed gets() from the code and am back in the situation where I input data. name and the code flips on without allowing for the next entry.
Jim, I scrapped part of my code and started again, applying your advice. After a good bit of tail biting I think I am finally making progress. I'd like to thank you. Zach.
By the way I would recommend Pelles C over DEV-C as it is probably more up to date with the current standards.
Also if the libraries you're talking about are things like conio, then you would probably be better off without it in the first place.
~~~~~~~~~~~~~~~~Quote:
Originally Posted by jimblumberg
DEV-C has an awful editor, but specifies errors during compile time. I like the editor of Pelle C, but the IDE was erroring out when DEV-C wasn't; neither did it specify errors. Which IDE would be your top choice?
Salem is right about prototyping functions, OP:Quote:
In C, you need to declare the prototype of the function (or define it altogether) before you use it.
But keep in mind you can also simply do this.Code:
#include <stdio.h>
void my_function(char*);
int main()
{
char* name = "Hello";
my_function(name);
}
void my_function(char* name)
{
printf("%s\n", name);
}
Code:void my_function(char* name)
{
printf("%s\n", name);
}
int main()
{
char* name = "Hello";
my_function(name);
}
That's probably because Pelles C is more up to date and has higher "default" error diagnostics.Quote:
I like the editor of Pelle C, but the IDE was erroring out when DEV-C wasn't; neither did it specify errors.
Truthfully I don't do Windows so neither of the above would be my choice, but of the two Pelles C. And since this is C I can't even recommend Visual Studio since it doesn't support modern C.Quote:
Which IDE would be your top choice?
Of course if you're really adventurous you may want to consider Clang (part 1 and part 2 but make sure you follow the install instructions carefully (Don't ask me if it doesn't work, remember I don't do Windows).
[QUOTE=jimblumberg;1288747]That's probably because Pelles C is more up to date and has higher "default" error diagnostics.
Re your example of a function / stressing that functions need prototypes. (I never queried that.) in your example you use char*. That really itches my brain. Am I right in assuming that what in some language could be string x = "whatever", in C could be char* x = "whatever". So in other words, C, that doesn't have strings, does have strings after all? How would you describe char* (A lone wolf in the world of char?)
So who ever said C doesn't have strings? A general purpose language that doesn't have strings would really be very limited.Quote:
So in other words, C, that doesn't have strings, does have strings after all?
In C a string is an array of char terminated by the end of string character '\0'. Every string must have the end of string character, otherwise it is just an array of char and if you try to use any of the strXXX() functions you will invoke undefined behaviour.
Depending on content "char*" could describe a pointer to a single character or a pointer to an array of char.Quote:
How would you describe char* (A lone wolf in the world of char?)
When talking about function parameters the following are all equivalent: char* a, char a[], char[1000].
I never stated anything about needing function prototypes or creating the function before use that was already covered by others earlier in the topic. I was talking about you having a function without any parameters ie: myFunction(). In C having no parameters in the parameter list doesn't mean that the function has no parameters, it means it can have any number of parameters. If you want a function to have no parameters you need to state that by using void: myFunction(void).Quote:
Re your example of a function / stressing that functions need prototypes.
I just wanted to point out that in Windows, Visual Studio 2017 and 2019 easily install and support CLang "out of the box" - very easy setup and installation (basically just check the box, it does everything else), giving VS2017 and VS2019 Clang 8.0, with full features of the IDE.
[Warning] deprecated conversion from string constant to 'char*'Code:#include <stdio.h>
#include <string.h>
#include <stdio.h>
int main()
{
char* monkey = "what are you doing?";
puts(monkey);
getchar();
return 0;
}
Oh oh.
OK, (re: prototypes / re: I never stated anything about needing . . .) Apologies!! It was someone else who came up with the remark about prototyping and the char* example.
Well, as declared, a char * monkey represents a non constant string.Quote:
[Warning] deprecated conversion from string constant to 'char*'
const char * monkey = "whatever";
would declare that "whatever" is const, and can't be changed.
Yes, you're trying to assign a constant char array (a string literal) to a non-const char pointer.Quote:
[Warning] deprecated conversion from string constant to 'char*'
Oh oh.
It should be like the following:
Code:const char* monkey = "what are you doing?"; // Note you can't change the string because it is a string literal.
Yes, but make sure you head the advice. The compiler needs to know about the function before you try to use it, this means that you need to either create a prototype (a declaration) prior to using the function, or define the function prior to use. You also need to implement (a definition) of the function before you try to link the program. Remember creating a program from C code is broken into several steps, the Preprocessing step, the Compiling, then the linking.Quote:
It was someone else
Also C before C99 would allow default function arguments and return values, this is no longer allowed (you must implicitly state the return type and the type of each parameter in modern C).