[] Operator Overload not working

[noobcpp]

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

[robwhit]

try (*stak)[2]

-> dereferences the left hand side.

[noobcpp]

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

int operator[](int);

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

[anon]

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[].

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

[Elysia]

-> 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 <<

[noobcpp]

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 ??

[Elysia]

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

[noobcpp]

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

[Elysia]

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.

[noobcpp]

so if I do some Change on

int operator[](int);

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

array* stak = new array();

[CornedBee]

(*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.

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

cout << stak[2]

[robwhit]

Elysia how do you figure that?

edit: beaten a-gain.

[Elysia]

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

[whiteflags]

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

Compile first, kids.

#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.

[Elysia]

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

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.