pointers?

[polonyman]

im starting to understand how pointers work but i dont understand the point. intead of using the address of a variable in an application like uni might be a pointer to the location of dog. so if you make sumthin like

#include <iostream>
using namespace std;

int main()
{

    int i = 10;

    do {
        cout << i << endl;
        i = i - 1;
    } while (i > 0);

    cin.get();
    
    return 0;
}

isnt it better to just use the variable i instead of the pointer?

[quzah]

What if you need to pass a huge amount of data some place so you can work with it? Say you've got 100MB of data you want to pass off to another function. Do you propose passing all of that by value?

Quzah.

[Salem]

You have 5 arrays of numbers, with a different number of elements in each array.
Write a function which calculates the average of each array WITHOUT using any pointers.
Then try it with a pointer

[caroundw5h]

I think the preceeding wizards summed up why you'd really want to use pointers very nicely. Pointers enable you to reach out into main from a function and alter what is stored there.
Just remember pointers don't have to be used all the time. Sometimes you do have a choice. C passes objects by value to preserve the integrity of your data, its actually a nice safeguard. When you must absolutely change an object - as quzah and salem expalined - you do so by going straight to its core - its address. As you get deeper into pointers you'll realise not only how powerful they are but also essential. You learn a great deal when you get there.
Do a search for pointers on the board, you'll find a huge amount of documentation.
Here is the classic case

[Nyda]

What if you need to pass a huge amount of data some place so you can work with it? Say you've got 100MB of data you want to pass off to another function. Do you propose passing all of that by value?

Since these are the C++ boards, one should mention that this could be very well done with references - probably even should be done.

As for the array problem, one would probably write a function to compute the average of one array and reuse it for all 5 arrays. Unless the whole averaging process is within another loop with a high number of iterations, the performance overhead is minimal and it allows that function to be reused for other purposes.

[The Brain]

try implementing a linked list without using pointers.

[Prelude]

>try implementing a linked list without using pointers.

#include <iostream>
#include <vector>

struct node {
  int data;
  int next;

  node ( int init, int link )
    : data ( init ), next ( link )
  {}
};

int main()
{
  std::vector<node> list;

  // Head insertion
  list.push_back ( node ( 0, -1 ) );
  for ( int i = 1; i < 10; i++ )
    list.push_back ( node ( i, i - 1 ) );

  for ( int i = list.size() - 1; list[i].next != -1; i = list[i].next )
    std::cout<< list[i].data <<"->";
  std::cout<<std::endl;

  list.clear();

  // Tail insertion
  list.push_back ( node ( 0, -1 ) );
  for ( int i = 1; i < 10; i++ ) {
    list.back().next = i;
    list.push_back ( node ( i, -1 ) );
  }

  for ( int i = 0; list[i].next != -1; i = list[i].next )
    std::cout<< list[i].data <<"->";
  std::cout<<std::endl;
}

[The Brain]

that.. is mighty impressive i must say.

[Prelude]

>that.. is mighty impressive i must say.
A linked list is an abstraction, much like a stack or a queue. It consists of a sequence of nodes that have references to the next node in the sequence. To fully understand the abstraction you need to realize that the reference doesn't have to be a memory address as long as you can use it to find the node you want. From there it's obvious how to write a linked list without explicit pointers. It's also obvious how languages that lack pointers can implement linked data structures.

[Hunter2]

>>try implementing a linked list without using pointers.
Hm. How about passing a "N/A" value without pointers, when every possible value is valid?

*EDIT: Ooops. Validation flags...

[Prelude]

>*EDIT: Ooops. Validation flags...
Yep. If all values are considered valid (or the error value is impractical) then you need another way of notifying the caller of an error. This is where things get interesting (and often ugly).