Попробуйте этот код. Надеюсь, вы получите свой результат.
filePath="C:\Users\admin\Desktop\Qtpfile.txt"
strModifytest=""
Set oFso = CreateObject("Scripting.FileSystemObject")
Set oFile = oFso.OpenTextFile(filePath, 1, True)
strContents = Split(oFile.ReadAll, vbCrLf)
strModifytest=Replace(strContents(0), "Header","NewHeader") & vbCrLf
For i=1 To UBound(strContents)-1
strModifytest=strModifytest & strContents(i) & vbCrLf
Next
MsgBox strModifytest
Set oFso1 = CreateObject("Scripting.FileSystemObject")
Set oFile1 = oFso1.OpenTextFile(filePath, 2, True)
oFile1.Write(strModifytest)
Пожалуйста, дайте мне знать, если это работает.
Вы пропустили "двойную" часть двойной отправки.
Точка этого шаблона должна удостовериться, что правильный метод процессора называют - метод, который принимает правильный тип. Так как процессор первоначально не знает о типе объекта, это передается ему, Вам нужен объект сказать процессор, каков его тип.
В сущности каждому объекту нужно виртуальное processMe(Processor &p)
метод и процессор называют его. Реализация processMe
вызовы p.processObject(this)
. Но на этот раз, "это" имеет известный тип! Таким образом вместо бесконечной рекурсии, Вы заканчиваете с правом proceessObject
названный
Шаблон "посетитель" разработан только для обработки этого вида ситуации.
Необходимо будет поместить виртуальный метод на BaseClass для вызова processObj от производных классов.
class BaseClass{
public:
BaseClass(){}
virtual void ProcessThis(Processor &p) { p.processObj(this); }
virtual void myFunction(){cout << "base myFunction called" << endl;}
};
class Derived1: public BaseClass{
public:
Derived1():BaseClass(){}
void ProcessThis(Processor &p) { p.processObj(this); }
void myFunction(){cout << "Derived1 myFunction called" << endl;}
};
class Derived2: public BaseClass{
public:
Derived2():BaseClass(){}
void ProcessThis(Processor &p) { p.processObj(this); }
void myFunction(){cout << "Derived2 myFunction called" << endl;}
};
class Derived3: public BaseClass{
public:
Derived3():BaseClass(){}
void ProcessThis(Processor &p) { p.processObj(this); }
void myFunction(){cout << "Derived3 myFunction called" << endl;}
};
class Processor{
public:
Processor(){}
virtual void processObj(BaseClass* bc){cout << "got a base object" << endl; bc->myFunction();}
virtual void processObj(Derived1* d1){cout << "got a derived1 object" << endl; d1->myFunction();}
virtual void processObj(Derived2* d2){cout << "got a derived2 object" << endl; d2->myFunction(); }
};
int main() {
BaseClass *bcp=new BaseClass();
Derived1 *dc1p=new Derived1();
Derived2 *dc2p=new Derived2();
Derived3 *dc3p=new Derived3();
Processor p;//can also use Processor* p = new Processor()
//first set results
bcp->ProcessThis(p);
dc1p->ProcessThis(p);
dc1p->ProcessThis(p);
dc3p->ProcessThis(p);
BaseClass *bcp1=bcp;
BaseClass *dc1p1=dc1p;
BaseClass *dc2p1=dc2p;
BaseClass *dc3p1=dc3p;
//second set results
bcp1->ProcessThis(p);
dc1p1->ProcessThis(p);
dc2p1->ProcessThis(p);
dc3p1->ProcessThis(p);
Processor p2;
bcp1->ProcessThis(p2);
dc1p1->ProcessThis(p2);
dc2p1->ProcessThis(p2);
dc3p1->ProcessThis(p2);
return 0;
}
Вы в основном хотите Шаблон "посетитель", но только с одним типом посетителя. Вы могли бы сохранить себя некоторое будущее усилие и превратить Процессор в абстрактный класс и реализовать один конкретный класс ProcessorImpl, делая это тривиальным для добавления другого класса процессора в будущем, или Вы могли ожидать, пока та ситуация не подходит и вещи отпуска, как на данный момент.
Огромное спасибо. Это решило мою проблему, и я понимаю то, что дважды диспетчеризирует средства! Вот полный код для потомства (кто-то, учите меня, как разобраться в форматировании):
#include <iostream>
using namespace std;
class BaseClass;
class Derived1;
class Derived2;
class Derived3;
class Processor {
public:
Processor(){}
virtual void processObj(BaseClass* bc);
virtual void processObj(Derived1* d1);
virtual void processObj(Derived2* d2);
};
class BaseClass{
public:
BaseClass(){}
virtual void ProcessThis(Processor &p) { p.processObj(this); }
virtual void myFunction(){cout << "base myFunction called" << endl;}
};
class Derived1: public BaseClass{
public:
Derived1():BaseClass(){}
void ProcessThis(Processor &p) { p.processObj(this); }
void myFunction(){cout << "Derived1 myFunction called" << endl;}
};
class Derived2: public BaseClass{
public:
Derived2():BaseClass(){}
void ProcessThis(Processor &p) { p.processObj(this); }
void myFunction(){cout << "Derived2 myFunction called" << endl;}
};
class Derived3: public BaseClass{
public:
Derived3():BaseClass(){}
void ProcessThis(Processor &p) { p.processObj(this); }
void myFunction(){cout << "Derived3 myFunction called" << endl;}
};
void Processor::processObj(BaseClass* bc){cout << "got a base object" << endl; bc->myFunction();}
void Processor::processObj(Derived1* d1){cout << "got a derived1 object" << endl; d1->myFunction();}
void Processor::processObj(Derived2* d2){cout << "got a derived2 object" << endl; d2->myFunction(); }
int main() {
BaseClass *bcp=new BaseClass();
Derived1 *dc1p=new Derived1();
Derived2 *dc2p=new Derived2();
Derived3 *dc3p=new Derived3();
Processor p;//can also use Processor* p = new Processor()
//first set results
bcp->ProcessThis(p);
dc1p->ProcessThis(p);
dc2p->ProcessThis(p);
dc3p->ProcessThis(p);
BaseClass *bcp1=bcp;
BaseClass *dc1p1=dc1p;
BaseClass *dc2p1=dc2p;
BaseClass *dc3p1=dc3p;
//second set results
bcp1->ProcessThis(p);
dc1p1->ProcessThis(p);
dc2p1->ProcessThis(p);
dc3p1->ProcessThis(p);
Processor p2;
bcp1->ProcessThis(p2);
dc1p1->ProcessThis(p2);
dc2p1->ProcessThis(p2);
dc3p1->ProcessThis(p2);
return 0;
}