基类中重载运算符 <<；

有一个专用来处理基类对象的函数；

如果对这个函数传入的参数是单个对象，那么通常情况下这个函数可以接收基类对象，也可以接收派生类对象，这是C++的多态特性决定的；

但是如果这个函数处理的是对象数组，因为指针算数表达式的工作原理，这个函数只能用来处理基类对象数组，虽然在函数形式上也可以接收派生类对象数组，但是函数的处理结果是不可控的，因经过函数内部的指针运算后，指针指向的地址里的内容是不可控的。

验证函数如下：

#include<iostream>
//#include <ostream>
#include "BaseClass.h"
#include "DerivedClass.h"

void printBaseArray(std::ostream& s,const BaseClass array[],int numElement);

void main()
{
	BaseClass baseObj0(2,3);
	DerivedClass derivedObj3(1,2,3);
	BaseClass baseObj9(1,5);
	BaseClass baseArray[10];
	DerivedClass derivedArray[10];

	baseArray[0] = baseObj0;
	baseArray[3] = derivedObj3;
	baseArray[9] = baseObj9;

	derivedArray[0] = derivedObj3;
	derivedArray[3] = derivedObj3;
	derivedArray[9] = derivedObj3;
	
	std::cout << "**** baseArray ****" << std::endl;
	printBaseArray(std::cout,baseArray,10);
	std::cout << "\n**** derivedArray ****" << std::endl;
	printBaseArray(std::cout,derivedArray,10);		// build ok,but will get unexpected result

	getchar();
	return;
}

void printBaseArray(std::ostream &s, const BaseClass array[],int numElement)
{
	for (int iloop1 = 0; iloop1 < numElement;iloop1 ++)
	{
		s << "array" << iloop1 << ":   " << array[iloop1] << "\n";
	}
}

验证结果如下，通过观察验证结果，我们可以看到函数在处理基类对象数组时候，输出的结果如我们预想的一样，但是在处理派生类对象数组的时候，输出的结果却是与我们的期望相差很远，除了array0的那一行输出，这是因为这一步的时候函数还没有对数组指针进行操作。

其他文件中的代码如下

基类声明

#ifndef BASECLASS_H
#define BASECLASS_H
#include<iostream>
#include <ostream>


class BaseClass
	{
	public:
		BaseClass();
		BaseClass(int a,int b);
		~BaseClass();
		void FuncPub();
		friend std::ostream &operator<<(std::ostream & os,const BaseClass &bas);

	private:
		void FuncPri();

	private:
		int numA;
		int numB;

	};


#endif

基类实现

#include "BaseClass.h"


BaseClass::BaseClass()
{
	numA = 0;
	numB = 0;
}

BaseClass::BaseClass(int a,int b)
{
	numA = a;
	numB = b;
}

BaseClass::~BaseClass()
{

}

std::ostream &operator<<(std::ostream & os,const BaseClass &bas)
{
	os << "numA = " << bas.numA << ";  numB = " << bas.numB;
	return os;
}

void BaseClass::FuncPri()
{
	return;
}

void BaseClass::FuncPub()
{
	return;
}

派生类声明

#ifndef DERIVEDCLASS_H
#define DERIVEDCLASS_H
#include "BaseClass.h"

class DerivedClass : public BaseClass
{
public:
	DerivedClass();
	DerivedClass(int cd);
	DerivedClass(int ad,int bd,int cd);
	~DerivedClass();
	void DerivedClass::FuncPri2();

public:
	int numC;

};

#endif

派生类实现

#include "DerivedClass.h"

DerivedClass::DerivedClass():BaseClass()
{
	numC = 0;
}

DerivedClass::DerivedClass(int cd):BaseClass()
{
	numC = cd;
}

DerivedClass::DerivedClass(int ad,int bd,int cd):BaseClass(ad,bd)
{
	numC = cd;
}

DerivedClass::~DerivedClass()
{

}

void DerivedClass::FuncPri2()
{
	return;
}