Printable View
i am trying to have the user chose the size of the array
what am i doing wrong?
Code:#include <stdio.h>
#include <stdlib.h>
main (){
int size;
int array [size];
printf("Please enter the size of the array", size);
scanf("%i", size);
system("pause");
}
Well for a start 'size' is undefined when you declare the array.
Two things are wrong.
First, it's against the "law". When you declare "array", size is uninitialized. If you want a random sized array, you should malloc a chunk of storage from the heap.
Second, your scanf should pass the address of size, not size itself.
Todd
Main returns int.
Size contains garbage at the point you try to allocate the array, so theoretically it could get an undefined size. Secondly, this is only allowed in C99 and not C89.
Thirdly, C is a linear programming language. One statement is executed after the other.
Do the array won't be created after you've asked the size, it will be created before because the line is before the input.
Fourthly, I think you need to take another look at printf.
And avoid system("pause"). Better to use getchar().
1. It's not part of C89 standard to use variable size arrays. To be portable to C89 compilers, you should use dynamic memory allocation.
2. You can not declare a variable size array before the size component has been assigned. Right now, when you are saying "int size;" , size contains some "random" value, and then try to create an array of that size. [The "random" value is usually the same for the same piece of code each time, but it's random in the sense that it's not defined by any standard and it may well change if you introduce another variable before it, change your code in some other way, change the compile options, etc, etc]
So, if you want to use the C99 feature of variable sized arrays, you should at least set the size before creating the array.
--
Mats
would this work?Code:#include <stdio.h>
#include <stdlib.h>
main (){
int size;
int array [1];
printf("Please enter the size of the array", size);
scanf("%i", size);
array[size];
system("pause");
}
would array size be what the user enters now?
It would be 1.
As I mentioned, it's linear. It won't just jump back and set a new size.
And array[size] just access the element size in the array.
Fix main and system("pause"), then go learn dynamic memory, malloc & free.
i have read my book but its too complicated so i am not understanding much of it
thats y i am trying to get some help here
Go learn this too: http://www.cppreference.com/stdio/scanf.html
Well, you need to understand pointers first.
Then you simply call malloc to allocate requested amount and when you don't need it, you call free.
Code:int main()
{
int* pArray;
int size;
printf("Enter size: ");
scanf("%i", &size);
pArray = malloc(size * sizeof(*pArray));
free(pArray);
pArray = NULL;
getchar();
return 0;
}
Can I also point out that allocating or sizing arrays dynamicly is OFTEN not necessary - unless your application is large and/or uses A LOT of memory, just using "sufficiently large" arrays [e.g. an int array[10000]; will use 40KB of memory, which is not very much when your system has 10000x as much memory].
--
Mats
am i on the right path?
what does error C2040: 'makeAnArray' : 'int *()' differs in levels of indirection from 'int ()' mean?Code:#include <stdio.h>
#include <stdlib.h>
main (){
int size;
printf("Please enter the size of the array", size);
scanf("%i", size);
makeAnArray(size);
system("pause");
}
int* makeAnArray(size){
int* array;
array=calloc(size,sizeof(int));
return array;
}
it point to the line: int* makeAnArray(size){
how do i fix that?
Sheesh. Start listening.
You are also missing a prototype for makeAnArray.Code:#include <stdio.h>
#include <stdlib.h>
// MAIN RETURNS INT
int main (){
int size;
// YOU HAVEN'T SPECIFIED ANYTHING FOR PRINTF TO PRINT, SO REMOVE THE "size" PART
printf("Please enter the size of the array");
// SCANF TAKES A POINTER
scanf("%i", &size);
makeAnArray(size);
// DON'T USE SYSTEM("PAUSE")
getchar();
}
// ALL ARGUMENTS MUST HAVE A TYPE
int* makeAnArray(int size){
int* array;
array=calloc(size,sizeof(int));
return array;
}
And you are not freeing the return from calloc.
ANd missing storing the return from makeAnArray().Quote:
Originally Posted by Elysia
--
Mats
And, this is incorrect syntax:
Code:printf("Please enter the size of the array", size);
would free(array); be in main or function?
Once you free the memory, you can't use it anymore. So it must be done when you're finished with it. What does that tell you?
using system("pause") and gerchar() is that the same thing?
does the program stop so that I can see whats on the screen?
Yes.
This is just one of many methods to do it. If you have a debugger, you can just set a breakpoint at the last line.
In Visual Studio, you can run without debugging and it will hold the window open.
thanks
this is what i have so far and there is an enternal error
what am i doing wrong?
Code:#include <stdio.h>
#include <stdlib.h>
int* makeAnArray(int);
main (){
int size=0;
printf("Please enter the size of the array", size);
scanf("%i", &size);
makeAnArray(size);
array(free);
getchar();
}
int* makeAnArray(int size){
int* array;
array=calloc(size,sizeof(int));
return array;
}
Huh? You should be calling free with array as an argument, not call a function array() with the argument free, first of all.
Second, you are not "receiving" the array returned by makeAnArray() [as I pointed out in a previous post].
--
Mats
I repeat:
Code:int main (){
And then:Code:printf("Please enter the size of the array");
Don't omit variable names in prototypes.Code:int* makeAnArray(int size);
And lastly:
You let the return (your pointer!) from makeAnArray go lost. Without a trace. Thus the memory is leaked. Never to be found ever again until your app exits. Very bad.Code:makeAnArray(size);
array(free);
And what's "array(free)"?
You free using the function free().
here is what i have. i am still getting major error????Code:
#include <stdio.h>
#include <stdlib.h>
int* makeAnArray(int size);
int main (){
int size=0;
printf("Please enter the size of the array");
scanf("%i", &size);
makeAnArray(size);
free(makeAnArray);
getchar();
}
int* makeAnArray(int size){
int* array;
array=calloc(size,sizeof(double));
return array;
}
Do tell how you're supposed to free a function?
You need to assign the pointer returned by makeAnArray() to a pointer to int, and then free that pointer to int. Also the second argument to calloc() should be a sizeof(int), not sizeof(double).
the reason i put sizeof(double) is because the numbers that will be put into the array will be doubles. is that incorrect?
Then you need to allocate a pointer to double! You can't allocate int and use doubles!
i am not understand this, i understand what you are saying but where am i making the mistake?Quote:
Originally Posted by laserlight
what would i have to keep as an int since size is going into the function as an int???
or could i just make everyhting a double?
makeAnArray returns a value. You aren't storing it in a variable.
If you want to work with doubles, then allocate doubles.
If you want to work with integers, then allocate integers.
Don't do anything else. Change the function accordingly.
i changed everything over to doubles
not when i run the program i get this error box:
Windows has triggered a breakpoint in Assignment 8.1.exe.
This may be due to a corruption of the heap, which indicates a bug in Assignment 8.1.exe or any of the DLLs it has loaded.
This may also be due to the user pressing F12 while Assignment 8.1.exe has focus.
The output window may have more diagnostic information.
Code:#include <stdio.h>
#include <stdlib.h>
double* makeAnArray(double size);
int main (){
int size=0;
printf("Please enter the size of the array");
scanf("%i", &size);
makeAnArray(size);
free(makeAnArray);
getchar();
}
double* makeAnArray(double size){
int* array;
array=calloc(size,sizeof(double));
return array;
}
No you didn't.Quote:
Originally Posted by goran00
What the red bit does is give the function free() the address of makeAnArray - that is not a piece of memory that has been allocated through malloc/calloc, so it will not "go down well".Code:#include <stdio.h>
#include <stdlib.h>
double* makeAnArray(double size);
int main (){
int size=0;
printf("Please enter the size of the array");
scanf("%i", &size);
makeAnArray(size);
free(makeAnArray);
getchar();
}
double* makeAnArray(double size){
int* array;
array=calloc(size,sizeof(double));
return array;
}
--
Mats
Again, you can't free a function!
makeAnArray is a function!
You didn't allocate it with malloc or calloc, so you can't free it!
i changed that to free(array)
but the problem i am having with that is
error C2072: 'array' : initialization of a function
here is the code. How can i fix that
Code:#include <stdio.h>
#include <stdlib.h>
double* makeAnArray(double size);
int main (){
int array()={0};
int size=0;
printf("Please enter the size of the array");
scanf("%i", &size);
makeAnArray(size);
free(array);
getchar();
}
double* makeAnArray(double size){
int* array;
array =calloc(size,sizeof(double));
return *array;
}
OMG. I'm totally invisible today. Why am I wasting my time.
Indeed. You need to go back to basics. You don't seem to understand much about C, at all.
Go back to reading about variables, functions, arguments and return types. Then try again.