|
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...
|
|
|
|
|
Why use anything other than 0? It always works when the iterating a range and can just use the count. I see no benefit to using arbitrary offsets. If I saw them I would assume the code was a hack job, rather than a well designed or elegant piece of code, and that the code is confusing to anyone that doesn't know the reason (which would be everyone but the author, then maybe even the author if he picked it up later).
Even if you say something like from 3..9, you still have the problem of knowing whether you are starting with the 3rd or 4th element, and ending on the 9th or 10th element. It did not solve a thing. If you don't use zero as the index, there is always some a priori knowledge of the special case that you HAVE to know or document so it is easy to see and understand, which just increases the probability of a bug.
There is nothing gained except the ability to hack and it should not be encouraged as a principle of software development. That is like encouraging people us Goto or return in the middle of a function, to me.
I think this is why there is a lack of respect for VB coders. Their language of choice encourages bad technique. I prefer the codes look and the compiler tell me if I appear to be doing something stupid with warnings, rather than just hide it in the muck of verbosity and irregularity.
Just my opinion.
|
|
|
|
|
*pArray essentially means pArray[0]. Using pArray[1] and *pArray for same thing would be inconsistent and error prone.
A loop that starts from 0 would always end up counting the elements, no +1 or -1 would be required.
When building lifts starts with 0, and almost everyone can understand it, what the problem with 0-based indexing? 
|
|
|
|
|
Unfortunately there's a continent full of people who don't understand that lifts start at zero. They don't even understand that they are called lifts.
Phil
The opinions expressed in this post are not necessarily those of the author, especially if you find them impolite, inaccurate or inflammatory.
|
|
|
|
|
My experience also says something else too. People would ask for the lift to "come-down", or to "go-up". Instead of asking it to take you "where" you want to go.
For example, you are on 4th floor, want to goto ground floor, and lift is on 1st floor - they would press "UP" asking it to come up, take you. Instead of pressing "down", where you want to go!
|
|
|
|
|
Oh yeah.... I see that almost everyday and I think: "Hummm... it's gotta be the first time they are using the elevator".
If the above is true, then man, I think I'm the person who has seen the most people using the lift for the first time.
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
