Thread: 2 beginner questions

1) <iostream.h> is deprecated. <iostream> is standard. All of the new C++ Standard Library headers define their symbols in the std namespace, so to access them, you need to either a) import all symbols in the namespace (in the headers you've included) using 'using namespace std;' toward the top of your file (or at least in the scope where you use the symbols), b) use a 'using declaration' for each symbol (e.g. 'using std::cout; using std::endl; using std::cin;') before using the symbols, or c) prefix each one with 'std::' (e.g. 'std::cout << "Hello" << std::endl;'). Search the board, and you will see this has come up often (and there are some better explanations around).

2) You either need to supply the array with a constant value, use dynamic memory allocation (new[] and delete[]), or preferably, use std::vector.

Here is a short reference on vector: http://cppreference.com/cppvector.html

Cheers

>1) <iostream.h> is deprecated.
No, iostream.h is nonexistant. It was never a part of the standard, so how could it be deprecated?

Okay.. Fair enough... I've never really used pre-C++98.

>At the time ATT C++ was the standard.
De facto standard. And this doesn't change the fact that the .h headers were never a part of Standard C++.

Net result is, don't use the .h.

yeah dont use .h
Just because is old, it was used in C
and C++ is the super set,
anyway, you can use it, if you want.
Sorry, I would like to give you a better explanation , you deserve a better explanation,
but if you ask me use the std. is the better
and the better also is using std:: in every statment you use than the using namespace std;
look better and keep you away from possible troubles, just in case u are making a big proyect.
Hope that helps.

****************** abyss********************

Question 1:
I will break this into two parts.

Part 1: Don't use <iostream.h>. Therefore you must either use "using namespace std;" or use std::cout.

Part 2:
Why Not To Use "using namespace std;"

I find that particular thread to be an excellent resource, and think it should be stickied or added to FAQ (unless it will spark too much controversy).


Question 2:
You can keep a count of how many elements you input, you can use a std::vector so that it will keep track for you, you can use a terminating value to determine where the 'end' of the array is (i.e. use -1 or something to signal that there are no more elements past this point) - not recommended - or you can keep going until you crash from array index out of bounds

>Depends on how you define standard.
>While there was no official standards body involved everyone who wanted a piece of the market followed the ATT standards.
>In our industry that's all the standard you need
And your point is? You basically just agreed with me on all points, but with more words.

Really, I think using std::vector or std::deque would be a better solution - they'll do the memory resizing and copying for you. Or if you don't need to access individual elements, you can use a std::list so that no copying needs to be done at all.

I see nothing wrong with the theory you have though, assuming an appropriate starting N is chosen - since the size of the array increases exponentially, you probably won't have to do too much copying unless you're inputting astronomical amounts of data. On the downside though, if you get a worst-case scenario you might have a lot of wasted memory.

That particular algorithm is fairly common for allocating memory for arrays. At any rate, your best bet is probably going to be a vector. Here is a small piece of example code that I wrote up to demonstrate its use:

Code:

#include <iostream>
#include <vector>

int main()
{
   std::vector<int> vec;

   std::cout << "Number of elements: ";
   std::flush(std::cout);
   
   // There should be some input checks, but that is not the point of this
   // example, so I'll leave it out. Assume the user is smart enough to enter
   // a positive integer.
   int n;
   std::cin >> n;
   
   for(int i = 0; i != n; ++i)
   {
      // Add some value to the end of the vector.
      // In this case, the value 17i mod 9 is pushed onto the back.
      vec.push_back((17 * i) % 9);
   }

   // And now, for accessing.
   std::cout << "Accessing via iterator:" << std::endl;
   std::vector<int>::const_iterator it;
   for(it = vec.begin(); it != vec.end(); ++it)
   {
      std::cout.width(2);
      std::cout << *it; // "Dereference" the iterator. (Get the value stored
                        // in the indicated poisition.)
   }
   std::cout << std::endl;
   
   std::cout << "Accessing via index:" << std::endl;
   std::vector<int>::size_type i;
   for(i = 0; i != vec.size(); ++i)
   {
      std::cout.width(2);
      std::cout << vec[i];
   }
   std::cout << std::endl;

   std::cout << "Accessing via at():" << std::endl;
   std::vector<int>::size_type j;
   for(j = 0; j != vec.size(); ++j)
   {
      std::cout.width(2);
      std::cout << vec.at(j); // Like indexing, but throws an exception if you
                              // overrun the bounds of the vector.
   }
   std::cout << std::endl;
   
   return 0;
}