[] Operator Overload not working

If I use cout<<stak->operator[](2) It works
But If I use
cout<<stak[2]<<endl
I shows a lot errors from ostream
----------------
error: no match for 'operator<<' in 'std::cout << *(
and many more
-----------
I think this means stak[2] is not returning int
but stak->operator[](2) is returning
I cant understand any reasons for this
can anybody help me out Plese ??
I am using GCC on Debian
with KDevelop IDE
My Full source Code is
http://rapidshare.com/files/11053475...st.tar.gz.html
If you are browsing the source Code Look at line 50 and 51 of linkedlist.cpp

try (*stak)[2]

-> dereferences the left hand side.

Thanks Worked
But what should my operator ocerload method signature be to use stak[2] simply ?
My Current One is

Code:

int operator[](int);

Code:

int array::operator[](int i){
	return at(i);
}

It already works, but stak is a pointer to array, not an array, and therefore you need to dereference it first before you can call the operator[].

Code:

int main()
{
    //array* stak = new array;
    array stak;
    std::cout << stak[0];
}

-> is used to access members on a variable, which clearly stak did not have. Instead you try to access a member of stak named operator <<

I need to us New
array* stak = new array(5);
and the overload[] must work with pointer to
what I need to do for that ??

Arrays and pointers work the same in this regard. Anon's solution works for pointers, as well.

Dereferencing is annoying It doesnt look good to use (*stak)[2] instead of stak[2]
Is it impossible ??

Originally Posted by noobcpp

Dereferencing is annoying It doesnt look good to use (*stak)[2] instead of stak[2]
Is it impossible ??

(*stak)[2] is actually equal to (**stak)[2].
And
stak[2] is actually equal to (*stak)[2].
This is how the compiler sees it, but you type the first.

so if I do some Change on

Code:

int operator[](int);

signature of array Class
would it be possible to use stak[2] if

Code:

array* stak = new array();

(*stak)[2] is actually equal to (**stak)[2].

What??? What utter nonsense! There's a level of indirection of difference here.

You cannot overload operator for types that aren't user-defined. Raw pointers of any kind are not user-defined, thus you cannot overload [] for array*.

You could just define an alias.

Code:

array *pstak = new array(5);
array &stak = *pstak;

cout << stak[2]

Elysia how do you figure that?

edit: beaten a-gain.

It means that operator [] dereferences the pointer.
p[0] == *p
*p[0] == **p

Originally Posted by Elysia

It means that operator [] dereferences the pointer.
p[0] == *p
*p[0] == **p

Compile first, kids.

Code:

#include <iostream>
#include <ostream>
#include <cstddef>

class array
{
public:
    explicit array ( std::size_t sz ): p( new int[sz] ), size( sz )
    {
        if ( size <= 0 ) {
            throw length_error();
        }
    }
    ~array ( ) { delete [] p; }
    const int & operator[] ( std::size_t idx ) const  { return p[idx]; }
    int & operator[] ( std::size_t idx ) { return p[idx]; }
    // ...
private:
    class length_error { };
    int * p;
    size_t size;
};

int main ( )
{
    array * stak = new array( 5 );
    std::cout << ( **stak )[0] << std::endl; 
}

Compiling...
learn.cpp
c:\documents and settings\jck\my documents\visual studio 2005\projects\learn\learn\learn.cpp(27) : error C2100: illegal indirection
Build log was saved at "file://c:\Documents and Settings\JCK\My Documents\Visual Studio 2005\Projects\learn\learn\Debug\BuildLog.htm"
learn - 1 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Price is right fail music would be nice here.

You cannot dereference a pointer more than once, of course. Duh. It works if it's a pointer to pointer.

Code:

int main( )
{
	int* p;
	int** p2;

	*p;
	p[0];

	*p2;
	**p2;
	p2[0];
	*p2[0];
	p2[0][0];
}

Compiles fine.
Don't run it, though.