Printable View
Hello to everyone! I've just started studying C++ on the college, and in the program I'm working on I have this:
Before you ask, I did included any necessary libs. I get Visual Studio saying the error is in the last line: "... constant value expected..."Code:int num = 0;
cin << num;
int array[num];
:confused: What the hell is going on? I know this is simple, but I can't figure it out :p .
Thanx in advance! C ya!
use new to allocate the memory. BTW: your use of cin is incorrect.
Code:int num = 0;
cin >> num;
int * array = new int[num];
Sorry about the cin :D kinda hurry. Now, maybe you have mistaken or something (I shouldn't use keywords in the code :p ). Here's the code I wanted:
Ok, now this is what I've got with your help:Code:int num = 0;
cin >> num;
int numbers[num];
Now just one doubt: in the Visual Studio, the window LOCALS (where I can see my variables values), the numbers int is shown an error, that the expression cannot be evaluated...Code:int num = 0;
cin >> num;
int * numbers = new int[num];
Will I have an array of the size of NUM with that anyway? Thanx 'til now!
new will allocate an array of num number of integers. you can access variable numbers the same way you would had you hardcoded the size
Code:int * numbers = new int[num];
for(int i = 0; i < num; i++)
numbers[i] = 0;
Allrighty! Thanx a lot man!!!
please don't tell people how to use new without telling them about delete...
you need to delete (or free up) the memory you've allocated with new... so for example:
if you forget to delete, you run into what's called a memory leak... it can cause big problems in some cases.Code:int*numbers=new int[num];
//other code goes here
//when you're done with the array use this next line
delete[]num;
Ok, thanx for the note!
now that you know how to use new and delete for arrays....
don't.
use a vector instead, and avoid the pain of trying to match new/delete pairs.
When using a pre set value to set the size of an array - the integer that you use must be of type constant. IE:Quote:
Originally Posted by lfbang87
I hope that explains your error.Code:const int num = 10;
int array[num];
what's so hard about matching new and delete?Quote:
Originally Posted by ChaosEngine
vectors take care of all that for you, but I still prefer new and delete (personal preference)
What if you want to resize the array? or concatenate 2 arrays together? suddenly the problem is far bigger than just matching new[] and delete[] ...Quote:
Originally Posted by major_small
I believe you need vector just when you want dynamic resize of a vector, i.e., use vector instead of realloc.
Just an opinion...
how so? just allocate a second (or third) array, put the data into that, and delete the original (two) array(s).Quote:
Originally Posted by Bench82
That's OK if you don't mind code fulll of new's and delete's, aswell as copying algorithms and temporary objects. But all that could easily be cut down to a line or two of STL code, and be much easier to read and debug IMO, especially when it comes to someone else trying to understand your code.Quote:
Originally Posted by major_small
it's all still pretty much the same amount of code, the only thing that really changes is who writes it ;)
:pQuote:
Originally Posted by ChaosEngine
Don't tell me you've never felt the urge to show off to the professor by including cool new code that the professor won't teach for another month.
This worked fine for me, if that's all you wanted
Code:#include <cstdlib>
#include <iostream>
using namespace std;
int main()
{
int num;
cout << "Enter the number of cells: ";
cin >> num;
int array[num];
for (int i = 0; i < num; i++)
{
array[i] = num;
}
for (int i = 0; i < num; i++)
{
cout << array[i] << " ";
}
cout << endl;
system("PAUSE");
return 0;
}
I agree with you. I use both C arrays and C++ vector. However, according to Programming Pearls, C arrays are much faster for sorting, for example (qsort vs. algorithm's sort). For simple array use, when you dont need the dynamic behavior, the std::vector implies in checks for increasing size, for example.Quote:
Originally Posted by major_small
Another advantage of std::vector over manually created dynamic arrays would be the use of RAII. I mean, you wont miss a delete[] because some maintenance programmer decided to insert a return somewhere before it, or some function called happens to throw an exception.
Of course, std::sort() can be used on C-style arrays as well, and can actually be faster than qsort().Quote:
However, according to Programming Pearls, C arrays are much faster for sorting, for example (qsort vs. algorithm's sort).
But then you are not using std::vector anymore, I am confused. The Programming Pearls used sort on vectors.Quote:
Originally Posted by laserlight
Also, acessing time for vector, using [] is slower than C style ;\
Consider this piece of code:Quote:
But then you are not using std::vector anymore, I am confused.
Code:const int size = 5;
int bar[size] = {3, 5, 1, 4, 2};
std::sort(bar, bar + size);
Premature optimisation is evil.Quote:
Also, acessing time for vector, using [] is slower than C style
Sorry to insist, but my point here is that you are not using vector anymore.Quote:
Originally Posted by laserlight
I will leave this as a personal preference. Since I work a lot with matrices, vector< vector<int> > would be twice as bad.Quote:
Originally Posted by laserlight
Actually, I was responding to your "qsort vs. algorithm's sort" comment.Quote:
Sorry to insist, but my point here is that you are not using vector anymore.
Have you actually profiled code to confirm this, or are you just taking what is written in "Programming Pearls" as holy scripture? Does the bottleneck in your code lie with the part that sorts the array/vector, and is the improvement really so great?Quote:
I will leave this as a personal preference. Since I work a lot with matrices, vector< vector<int> > would be twice as bad.
Uhm... I understand. Ok, std::sort on C arrays can be faster then qsort(). However, you are still using C array.
I havenīt profiled my code, and I agree that I could have been hasty. I will try to make some test with real code (applications) and if I have significant results (no matter if proves or not my point) I will tell them. I said that because, inspecting std::vector code, I saw that operator[] instantiates an iterator object. :)
>> This worked fine for me, if that's all you wanted
That works only on compilers (like gcc that comes with Dev-C++) that support the language extension. It is not standard C++ code. C99 allows it, which is why gcc allows it unless you turn off that extension. As soon as you switch the code to another compiler it will not work.
I would use a C-style array if I dont need a dynamic array.Quote:
However, you are still using C array.
That is probably implementation specific. From what I see, a vector should be no faster than a dynamic array, but for the most part it shouldnt have terrible performance either.Quote:
I said that because, inspecting std::vector code, I saw that operator[] instantiates an iterator object.
There is also boost::array which will likely be part of the next standard (it might already be part of TR1) which encapsulates plain, non-dynamic arrays. I would use that instead of a C-style array on a major project.
it is part of TR1.Quote:
Originally Posted by Daved
My main point about vectors is this... they work. If you use a vector correctly you don't need to worry about matching new and delete.
The reason C++ has a bad reputation for productivity is that developers spend too much time worry about stupid cr@p like matching new and deletes. If you asked a java/c#/python programmer to write code like that, they'd laugh at you. With vector, you create a vector and get on with solving the problem, not ........ing about with the language.Code:void PrintArray(int *pArray)
{
throw anException;
}
int main()
{
int* pArray = new int[5000];
try
{
PrintArray(pArray); // need to pass size
delete pArray; // ooops memory leak
}
catch (...){}
}
vectors are:
- generic
- exception safe
- "automatic"
- know their own size
arrays are:
- specific, you have to write the same code over and over
- not exception safe, they cause memory leaks unless you wrap them in a class, in which case you're just reimplementing a half assed vector
- manual, you have to remember to delete them, copy them, etc
- don't know their own size
Let me put this simply and in the strongest possible terms:
There is no place in modern C++ where a dynamically allocated array is a better solution then a container.
if you still don't believe me RTFFAQ
I want to get a user to input a phrase into a char array[x] and then find the length of it to be stored in a file. HOw woould I do this?
You should ask your question in its own thread. For C style strings (null terminated character arrays), you can use strlen to find the length of the string. However, in C++ you should use the C++ string class if you can.
Yes but I have the problem of reading the string once it has been put in the file.
Ask your question in its own thread, with code, example input and expected output.
am I the only one that sees this as the equivalent of "Why learn long division when we have calculators?"Quote:
Originally Posted by ChaosEngine
Learn long division and how to use calculators, but use calculators (unless you need long division, or can do the calculation mentally or on paper).Quote:
am I the only one that sees this as the equivalent of "Why learn long division when we have calculators?"
Learn dynamic arrays with new[]/delete[] and how to use vectors and other containers, but use vectors and other containers (unless you need dynamic arrays due to some exceptional reason).
I think the reason why it is good to learn both is that abstractions leak, but as long they dont, it makes more sense to use the abstraction.
Work out the following to as many decimal places as you can:Quote:
Originally Posted by major_small
123.45/234.567
645647.654/4353
Are you seriously telling me you're going to sit down and work them out by hand or are you going to use the tools available to you?
Of course you should learn and understand long division, but to suggest that you shouldn't automate it is just plain stupid.
We're computer programmers!!! The whole point of writing computer programs is to automate tasks, that are boring/error-prone/slow. Yet for some reason C/C++ programmers have this insane irrational fear that anything in a library must be inefficient. This is why people who write in other languages laugh at C/C++ programmers. This is why a script kiddie writing in c# can produce code faster than a typical C++ programmer with 3 or 4 years experience.
If you are writing code professionally, you better have a damn good reason for using a dynamic array over a vector, otherwise you are wasting your employers time/money.
Sorry, but this issue really annoys me.
About the only use for hand written arrays in C++ is when you have to communicate with older C libraries. for instance windows API
char *text = new char[128];
GetWindowText(hwnd, text, 128);
delete[] text;
other than that, best to use std::vector. The optimization argument can easily be wrong too these days, because inlining and the vector template fitting better into the C++ libraries can make vectors faster than C style arrays.
Actually, you can and should use vector in that instance as well:Code:vector<char> text(128);
GetWindowText(hwnd, &text[0], 128);
// no delete necessary
ow maybe you can give the definitive answer then. We had a discussion once if you could do this. It comes across kinda hackish because access to the internal mechanism of vector is given. But this would be perfectly safe?Quote:
Originally Posted by Daved
You couldnt do this with std::string for example because the length of the string wont necessarily be updated so you'd better do
std::string text = buf; and then delete buf after the call to GetWindowText
This is one instance where the internal representation is guaranteed by the standard, and it is done just for this purpose. In the 1998 standard it was somewhat ambiguous, but they corrected that recently and all major standard library implementations follow the practice anyway. The vector must hold its contents in contiguous memory, so that &v[0] can be used for backwards compatibility with functions taking C style arrays.
You couldn't do this with std::string because it's memory isn't guaranteed to be contiguous. The issue isn't with the length not being updated, because the length of the vector or the length of the character array aren't updated either. It is just that GetWindowText expects a contiguous array of modifiable characters that std::string cannot provide.
I would use vector, and then assign &v[0] to the string (since that would be the first character of a null terminated string). Using a local buffer is also fine, but I wouldn't use new[]/delete[] in this instance since the dynamic allocation is unnecessary.