为什么定义了类却提示使用了未定义的类？

[I_code]

先贴代码并在代码中说明情况：

#ifndef CHARREF
#define CHARREF
#include "myString.h"
class char_ref
{
	friend class myString;
	int i;
	myString* s;

	char_ref(myString* ss, int ii)
	{
		s = ss;
		i = ii;
	}

public:
	void operator=(char c)
	{
		s->r[i] = c;
	}
	operator char()
	{
		return  s->r[i];
	}
};
#endif

#ifndef MYSTRING
#define MYSTRING
#include "char_ref.h"
class myString
{
	friend class char_ref;
	char *r;
public:
	char_ref operator[](int i)  //如果将这个方法的定义去掉，是可以编译通过的，难道匿名类不是这么写的？
 	{
 		return char_ref(this, i);
 	}
};
#endif

#include "char_ref.h"
#include "myString.h"
#include <iostream>
using namespace std;

int main()
{
	return 0;
}

[imhxb]

匿名类不是java里的么
C++有么

[ryfdizuo]

class myString;

class char_ref
{
	friend class myString;
	int i;
	myString* s;

	char_ref(myString* ss, int ii);
public:
	void operator=(char c);

	operator char();
};

class myString
{
	friend class char_ref;
	char *r;
public:
	myString(char* str)
		: r(str)
	{}

	char_ref operator[](int i);
};

//-------------------------------------
// char_ref定义
//-------------------------------------
char_ref::char_ref(myString* ss, int ii)
{
	s = ss;
	i = ii;
}

void char_ref::operator=(char c)
{
	s->r[i] = c;
}
char_ref::operator char()
{
	return  s->r[i];
}

//-------------------------------------
// myString定义
//-------------------------------------
char_ref myString::operator[](int i) 
{
	return char_ref(this, i);
}

char s[] = {"hello world"};
myString mstr(s);
cout << mstr[3] << endl;

这样就OK了。

[sttony]

#ifndef CHARREF
#define CHARREF

//#include "myString.h" // 去掉这一行 加一行
class myString; // 试试

[I_code]

[Quote=引用 2 楼 dizuo 的回复:]

C/C++ code
class myString;

class char_ref
{
friend class myString;
int i;
myString* s;

char_ref(myString* ss, int ii);
public:
void operator=(char c);

operator char();
};
……
[/Quote]

感谢你的回答，果然声明与定义分开就OK了。我还想知道为什么，能解释一下么？

[测试NULL]

可以使用模板类来解决这个问题.

#include <iostream>
using namespace std;


#ifndef MYSTRING
#define MYSTRING
template<typename T> class char_ref;
template<typename T>
class myString
{
    friend class T;
    char *r;
public:
    T operator[](int i)  //如果将这个方法的定义去掉，是可以编译通过的，难道匿名类不是这么写的？
    {
        return T(this, i);
    }
};
#endif

#ifndef CHARREF
#define CHARREF
template<typename T>
class char_ref
{
    friend class myString<char_ref>;
    int i;
    myString<char_ref>* s;

public:
    char_ref(myString<char_ref>* ss, int ii)
    {
        s = ss;
        i = ii;
    }
    
public:
    void operator=(char c)
    {
        s->r[i] = c;
    }
    operator char()
    {
        return  s->r[i];
    }
};
#endif

int main()
{
    return 0;
}

[测试NULL]

那是因为你在如下代码中实例化了char_ref类(调用char_ref的构造方法):

char_ref myString::operator[](int i)
{
    return char_ref(this, i);
}

这段代码必须放到char_ref类的定义之后,
要不然在myString类中就无法知道如何去实例化char_ref类(调用char_ref的构造方法).

[I_code]

[Quote=引用 5 楼 wangliangffaflgh 的回复:]

可以使用模板类来解决这个问题.
C/C++ code


#include <iostream>
using namespace std;


#ifndef MYSTRING
#define MYSTRING
template<typename T> class char_ref;
template<typename T>
class myString
{
friend class……
[/Quote]
请问你是怎么想到这么改的？求教.

[I_code]

[Quote=引用 6 楼 wangliangffaflgh 的回复:]

那是因为你在如下代码中实例化了char_ref类(调用char_ref的构造方法):
C/C++ code

char_ref myString::operator[](int i)
{
return char_ref(this, i);
}


这段代码必须放到char_ref类的定义之后,
要不然在myString类中就无法知道如何去实例化char_ref类(调用char_r……
[/Quote]
写的很详细，谢谢了。

[测试NULL]

/* 用模板类来实现这个有点麻烦, 之所以会想到模板,是因为用模板可以实现编译时候的多态
请看下面的注释~~ */

#include <iostream>
using namespace std;


#ifndef MYSTRING
#define MYSTRING
template<typename T>
class myString
{
    friend class T;
    T* c;

public:
    char *r;

    myString(T* t)
    {
        c = t;
    }

    myString(char* str): r(str)
    {
    }

    T operator[](int i)
    {
        return T(this, i);
    }
};
#endif

#ifndef CHARREF
#define CHARREF
template<typename T>
class char_ref
{
    friend class myString<char_ref>;
    int i;
    myString<char_ref>* s;
    T* t;

public:
    char_ref(T* t)
    {
        lkjwalkgjwalwekjgwlkgjlwe //这边我乱写编译也不会报错, 但如果下面程序调用到了才会报错
        this->t = t;
    }

    char_ref(myString<char_ref>* ss, int ii)
    {
        s = ss;
        i = ii;
    }
    
public:
    void operator=(char c)
    {
        s->r[i] = c;
    }
    operator char()
    {
        return s->r[i];
    }
};
#endif

int main()
{
    int i;
    char s[] = {"hello world"};
    int nLen = strlen(s);

    //char_ref<char> c("test"); //将这个注释去掉会报错
    myString<char_ref<char> > m(s);

    for(i = 0; i < nLen; i++)
    {
        cout << (char)m[i];
    }
    cout << endl;

    m[4] = 'p';
    m[nLen-1] = 'u';

    for(i = 0; i < nLen; i++)
    {
        cout << (char)m[i];
    }
    cout << endl;

    return 0;
}