|
Me too, that would mean an over-population of VB coders! 
|
|
|
|
|
Never heard of FORTRAN? 
|
|
|
|
|
Even VB coders know that starting an array at 1 is just wrong. We did it for years because we had to, but we always felt guilty about it. 
There are two kinds of people. Those who need closure
|
|
|
|
|
I don't uderstand all the hate on VB programmer, its kinda discriminating, like somebody "is a lesser being" just because they use a language that somebody dislikes, or considers bad. Anyway I preffer starting in 0, eve though this disscussion is a little pointless and of obvious results.
|
|
|
|
|
I'm not a VB Coder, and never have been, im a Java, C#, and Pascal Coder, and i have been programming for 30 years.
And i have always thought that the first index of an array should be index 1.
'First' and 'One' simply match. Having to use the the length of whatever you are parsing 'minus 1' in every loop, is silly.
IMO 1 .. N, makes more sense than 0 .. N-1,
There are so many here defending the zero based index .. passionately even. Amazing.
|
|
|
|
|
mojp wrote: Having to use the the length of whatever you are parsing 'minus 1' in every loop, is silly.
If you run your loops with a limit < Length instead of <= Length-1 then you don't have to subtract 1 every time.
|
|
|
|
|
May be you should have started with C ...
Think about it another way:
- you have read NOTHING (count=0)
- you read in the FIRST element into an array (array[count]) ==> array[0]
- you increment the read counter (count++)
- you read in the NEXT element into the array (array[count]) ==> array[1]
after you finished, you have the count already.
Additionally, as many others mentioned, an array is nothing more than
an contingous area of memory, and (in C) a reference to the entire array
is the start address of the memory area (array == &(array[0])), and
you can also read an element with dereference of the pointer plus offset
*(array + offset) == array[offset] / array + offset = &(array[offest])
|
|
|
|
|
T GetRandomElement(T[] array)
{
return array[NextRand() % array.Length];
}
T[] Reverse(T[] input)
{
T[] output = new T[input.Length];
for (int i = 0; i < input.Length; i++)
output[output.Length - i] = intput[i];
return output;
}
Try doing these with 1-based arrays and you'll find that you'll need ugly "+1" for most of the array accesses.
In fact this extends to many algorithms; 0-based arrays tend to lead to cleaner code and less potential for off-by-one errors. Dijkstra's argument for 0-based arrays[^] explains why.
modified on Tuesday, March 8, 2011 1:48 AM
|
|
|
|
|
Starting from 0 is also consistent from a mathematical point of view: remind set theory, Peano axioms and natural numbers.
|
|
|
|
|
Does that code work? Because as I read it, say input has a length of 5 (0...4). i = 0 -> 4, therefore in your output = input line output[output.Length (5) - i (0)] is outside of your array. C isn't my primary language, so I might have got it wrong.
In VB, it would work by using UBound() instead of .Length.
I still advocate 0 as base element, because array's are pointers to a chunk of memory, and the element is an offset into that memory. Naturally, there is no offset (0) for the first element.
|
|
|
|
|
Here is where they get ugly:
You have a binary search that not only returns the index of the found item, but if the item is not found it returns the negative of the index that it would have had, had it been in the list. In other words if the user wants to check for duplicate values before inserting an item in the list then a result of say -4 tells him his new value is not in the list but can be inserted at position 4.
All good so far.
Now what happens if the new number is smaller than any number in the list (assuming the list is ascending). It must be inserted at index 0 (assuming 0 base array). What is the algorithm to return? It cannot return -1 because that means the insertion must be at index 1. And there is no -0 !
In my own implementation, in such case I am returning int.MinValue and check for it in the calling process. But it's ugly coding! 
|
|
|
|
|
You can just use ~ instead of -. At least that's what System.Array.BinarySearch is doing.
|
|
|
|
|
Actually,
I can't understand that,
the person or group who had firstly made array, what ever language he first created
why using 0 as starting point whereas it is very confusing.
i am confuse about it since i have started learning languages.........
Thanks........
|
|
|
|
|
Because in the early days there was no concept of an array, just a memory pointer.
So, to have a list of numbers, you set a pointer to the first one, and then added the length of the number in bytes to the pointer to get to the next.
When arrays where developed, the code was simple:
array[index] = 6 became
Set pointer to array start;
set accumulator to index;
multiply accumulator by array element length;
add accumulator to pointer;
Set contents of pointer to 6; So, arrays started at zero.
It does make sense, numbering starts at zero in nature: I have no oranges, I have one orange, I have two oranges...
Remember all the fun the Romans had, because they didn't have a zero? 
Real men don't use instructions. They are only the manufacturers opinion on how to put the thing together.
Manfred R. Bihy: "Looks as if OP is learning resistant."
|
|
|
|
|
It should start at 1, but the poll shows that the majority has been influnced by C-like languages and accepted the reality...
Best,
Jun
|
|
|
|
|
Well you can't realy expect after all this years using arrays starting in 0 everybody suddently thought "Oh wait, let's start by 1 instead beacuse we're kinda bored with the 0"
|
|
|
|
|
I've a devoted VB programmer... from VB3... zero based was always my preference. I don't really care personally, I just want uniformity and most major big boy languages (including VB) are default to or allow with a lot of use to zero based. In low level systems, it's a requirement. In high level systems it's trivial debate. We all use numbers for arrays (I hope, I've never seen a language that uses letters or counts pipe symbols) so lets just keep one rule.
When I actually thought about this argument I realized I've almost stopped using single dimensional arrays, which I feel like is the only type where this debate has real meaning. More complex collections objects are easier to use unless you really need the performance and multi dimensional arrays so often represent a physical plane which naturally starts at (0,0) or (0,0,0) I feel it's not worth the occasional loop help to have a 1-based system ever... come to think of it, I don't use For much either, always For Each and Do... Loop w/cursor (when deleting from collections).
|
|
|
|
|
I'm just glad they made their minds up and hope they stick with it. What pisses me off is when you run up against some antiquated tool that uses a different (1) base.
Never underestimate the power of human stupidity
RAH
|
|
|
|
|
Why not both? If you want your arrays to start at 1 then simply do not use the first (0) element. Sure it is a waste of memory, but nobody seems to care about memory any more as it is so cheap.
You may be right
I may be crazy
-- Billy Joel --
Within you lies the power for good - Use it!
|
|
|
|
|
Just to check, what's your choice:
Bacon
- or -
Tee Oh Eff Oh
Panic, Chaos, Destruction.
My work here is done.
or "Drink. Get drunk. Fall over." - P O'H
OK, I will win to day or my name isn't Ethel Crudacre! - DD Ethel Crudacre
|
|
|
|
|
CListCtrl
You may be right
I may be crazy
-- Billy Joel --
Within you lies the power for good - Use it!
|
|
|
|
|
You've already stepped in it. It's too late to invoke that control... 
".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass." - Dale Earnhardt, 1997
|
|
|
|
|
The problem with this is that most people are professionals and develop code professionally. This means code must be shared and co-maintained. Unless everybody is a VB developer this causes great confusion.
I used VB many years ago before C/C++ and now C#. It was for people that had no programming skills or training (as few did in those days) to be so verbose they could actually understand what was going on. It was been kept back then because of a legacy base that existed when real programming languages started emerging. Beginners thought it was the way to go because C and C++ were so complex relative to VB. So they stayed with it. VB has become close to as powerful a language as C++/C#. There are elegant things you can do with C#/C++ that you cannot do with VB. Dot Net has evened the power out.
But, there is no question that VB is a very ugly and busy language. The bounding of every declaration with an End statement and the Pascal Casing of keywords make it somewhat unreadable and cluttered so that it is harder to see what is really going on. VBers are used to it. C#/C++ers are not and it looks overly verbose. Even in the beginning where people used assembler because there were no real high level languages, the indexes always started with zero. VB adds a statement to subtract 1 from the index to use it. It has to because in memory arrays they have to use pointers and the index starts at the starting address without offsetting. No starting at zero would mean they would have decrement it for the loop in order to calculate the offset by multiply the entry size by the index. So it is more than just a waste of memory. It is also a waste of processing. Having to add the word DIM in order to declare a statement is pointless and even more cluttering. Instead of "typeof(x) you have to type TypeOf(x). That is too much usage of the shift key which slows typing. Especially if you turn the annoying syntax checker that won't let you leave the line until you fix any error in the syntax. I am still forced to use it for macros so I still get the pain. Having to know two different syntaxes is also a royal pain.
There is much bigotry against VB. I think I have listed what the main gripes are the over verbosity, silly syntax to "explain" the obvious, and the fact you don't know whether it is indexed by 0 or 1. These are unfortunate but they are legacy. They are not likely to change.
I am glad to see there is a rapid move away from VB. Having two primary languages litters the google search landscape. I don't think people use VB because they are simple minded. I just believe it is what they learned and they have experience on it and they don't want to change anymore than C# people would want to change to Java or some other language that they are not used to.
It is unfortunate that VB has this legacy. IF not for this gross mistake, this indexing issue would not exist because mid level languages ever attempted it because they saw redundant processing as a waste. As far as FORTRAN goes, it may be why VB got that tradition. But, it died on the vine long ago. VB hasn't. It is not as elegant and powerful at debugging syntax than C#. It is bad that Microsoft has to waste money with different compilers and editor support, when that time could be used to develop new tools or technologies which would benefit the entire programming world. But, it is what it is. Maybe in the future, the usage of VB would drop to a point that they could drop support for it.
|
|
|
|
|
Of course, the old VB, before .NET allowed you the ability to declare it either 0 or 1. Certainly, the atrocity of declaring an array with 10 elements and getting 11, 0 thru 10, is not the way to go.
Delphi allows you to declare an array starting with the positive integer of your choice, e.g.:
var Appointments : array[3 .. 9] of Integer; which would give you seven (7) elements.
Or you could do the usual:
var Appointments : array[0 .. 6] of Integer; for seven (7) elements.
Norman E. Fisher
|
|
|
|
|
To me that makes sense. It doesn't matter what you call it as long as it has the number of elements you require?
A rose by any other name...
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
