C++ Children类代码示例

Children mainParse(I& be, I& en,  Pos& pos) {
	Children ret;

	while(be != en) {
		eatWhitespaceComment(be, en, pos);

		if(test(be, en, "<{{")) {
			ret.push_back(std::move(parseC(be, en, pos)));	
		} else if(test(be, en, '<')) {
			ret.push_back(std::move(parseNode(be, en, pos)));
		} else if(test(be, en, '>')) {
			eat(be, '>', pos);
			break;
		} else {
			I iter;
			TNodeType type;	
			if(!test(be, en, "&{{") && *be == '&') {
		   		iter = eatUntil(be, en, "\n", pos);
				/*for(iter = be; !test(iter, en, '\n') && !test(iter, en, "//"); 
						increment(iter, pos)) 
				{
				}
				if(test(be, en, "//")) {
					eatWhitespaceComment(be, en, pos);
				}*/
				type = TNodeType::SingleCppLine;
			} else {
		   		iter = eatUntil(be, en, "\n>", pos);
				for(iter = be; 
					!test(iter, en, '\n') && !test(iter, en, "//") && !test(iter, en, '>'); 
					increment(iter, pos)) 
				{
				}
				if(test(be, en, "//")) {
					eatWhitespaceComment(be, en, pos);
				}
				type = TNodeType::Text;
			}
			auto posCopy = pos;
			//std::cout<<"||| "<<std::string(be, iter)<<std::endl;
			ret.push_back(
				std::make_unique<TNode>(std::string(be, iter), posCopy, type
				)
			);

			be = iter;

			char iterC = *iter;
			eat(be, iterC, pos);

			if(iterC == '>') 
			{
				break;
			}
		}
		eatWhitespaceComment(be, en, pos);
	}

	return ret;
}

void GeoRSSLayer::_read ( const std::string &filename, Usul::Interfaces::IUnknown *caller, Usul::Interfaces::IUnknown *progress )
{
  // Make sure the file exists before reading.
  if ( false == boost::filesystem::exists ( filename ) )
    return;

  // Set the name.
  if ( true == this->name().empty() )
    this->name ( this->url() );

  // Scope the reading flag.
  Usul::Scope::Caller::RefPtr scope ( Usul::Scope::makeCaller ( boost::bind ( &GeoRSSLayer::reading, this, true ), 
                                                                boost::bind ( &GeoRSSLayer::reading, this, false ) ) );

  // TODO: I think a SAX parser is more appropraite here, because we can stop the parsing if there isn't new data.
  XmlTree::Document::RefPtr doc ( new XmlTree::Document );
  doc->load ( filename );

  // Get the date the stream was modified.
  Children lastPubDateNode ( doc->find ( "lastBuildDate", true ) );
  const std::string date ( false == lastPubDateNode.empty() ? lastPubDateNode.front()->value() : "" );
  boost::posix_time::ptime utcTime ( Minerva::Core::Data::Date::createFromRSS ( date ) );

  boost::posix_time::ptime lastDataUpdate ( Usul::Threads::Safe::get ( this->mutex(), _lastDataUpdate ) );

  std::cout << "Last data update: " << lastDataUpdate << std::endl;
  std::cout << "Last feed update: " << utcTime << std::endl;

  // Check the date against the time time we updated.
  if ( false == this->dirtyData() && false == lastDataUpdate.is_not_a_date_time() && false == utcTime.is_not_a_date_time() )
  {
    // Return now if the feed has not been updated.
    if ( lastDataUpdate >= utcTime )
    {
      // Our data doesn't need to be updated.
      this->dirtyData ( false );
      return;
    }
  }

  // Clear what we have.
  this->clear();

  unsigned int i ( 0 );

  // Get all the items.
  Children children ( doc->find ( "item", true ) );
  BOOST_FOREACH ( XmlTree::Node::ValidRefPtr node, children )
  {
    std::cout << "Adding item " << ++i << " of " << children.size() << std::endl;
    this->_parseItem( *node );
    
    if ( this->size() >= this->maximumItems() )
      break;
  }

void Panel::Clear()
{
    // Clear children
    Children aspChildren = m_aspChildren;
    for ( Children::reverse_iterator it = aspChildren.rbegin(); it != aspChildren.rend(); ++it )
    {
        GuiObjectPtr spChild = *it;
        spChild->Clear();
        RemoveChild( spChild );
    }

    GuiObject::Clear();
}

void BrowsingContext::Detach(bool aFromIPC) {
  MOZ_LOG(GetLog(), LogLevel::Debug,
          ("%s: Detaching 0x%08" PRIx64 " from 0x%08" PRIx64,
           XRE_IsParentProcess() ? "Parent" : "Child", Id(),
           mParent ? mParent->Id() : 0));

  RefPtr<BrowsingContext> kungFuDeathGrip(this);

  BrowsingContextMap<RefPtr>::Ptr p;
  if (sCachedBrowsingContexts && (p = sCachedBrowsingContexts->lookup(Id()))) {
    MOZ_DIAGNOSTIC_ASSERT(!mParent || !mParent->mChildren.Contains(this));
    MOZ_DIAGNOSTIC_ASSERT(!mGroup || !mGroup->Toplevels().Contains(this));
    sCachedBrowsingContexts->remove(p);
  } else {
    Children* children = nullptr;
    if (mParent) {
      children = &mParent->mChildren;
    } else if (mGroup) {
      children = &mGroup->Toplevels();
    }

    if (children) {
      // TODO(farre): This assert looks extremely fishy, I know, but
      // what we're actually saying is this: if we're detaching, but our
      // parent doesn't have any children, it is because we're being
      // detached by the cycle collector destroying docshells out of
      // order.
      MOZ_DIAGNOSTIC_ASSERT(children->IsEmpty() || children->Contains(this));

      children->RemoveElement(this);
    }
  }

  if (mGroup) {
    mGroup->Unregister(this);
  }

  // As our nsDocShell is going away, this should implicitly mark us as closed.
  // We directly set our member, rather than using a transaction as we're going
  // to send a `Detach` message to other processes either way.
  mClosed = true;

  if (!aFromIPC && XRE_IsContentProcess()) {
    auto cc = ContentChild::GetSingleton();
    MOZ_DIAGNOSTIC_ASSERT(cc);
    cc->SendDetachBrowsingContext(this, false /* aMoveToBFCache */);
  }
}

 void findAllUnresolvedSymbols(std::vector<ParseItem>* pItems) const
 {
    // Get the unresolved symbols at this node
    std::set<ParseItem> unresolved = getUnresolvedSymbols();
    pItems->insert(pItems->end(), unresolved.begin(), unresolved.end());
    
    // Apply this over all children on the node
    Children children = getChildren();
    
    for (Children::iterator it = children.begin();
         it != children.end();
         ++it)
    {
       (**it).findAllUnresolvedSymbols(pItems);
    }
 }

void InstanceArray::bindToMasterView(const ViewSharedPtr& inMaster, bool inMapPortReferences)
	throw (Error) {
	typedef std::vector<InstanceSharedPtr> Children;
	Children children;
	getChildren(children);
	Children::iterator child = children.begin();
	Children::iterator cEnd = children.end();
	for(; child != cEnd; ++child) {
		try {
			(*child)->bindToMasterView(inMaster);
		} catch(Error& e) {
			e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
			throw;
		}
	}
	Instance::bindToMasterView(inMaster, false);
}

void FontSizeComboBox::setActiveFontSize(int value)
{
	if (value == 0)
	{
		unset_active();
		return;
	}
	
    typedef Gtk::TreeModel::Children Children;
    Children children = font_size_tree_model_->children();
    for (Children::iterator iter = children.begin(); iter != children.end(); ++iter)
	{
		Gtk::TreeModel::Row row = *iter;
		if (row[columns_.font_size] == value)
		{
			set_active (iter);
			break;
		}
	}
}

void cHandler::GetChildren( Children& children ) const
{
    cObject::GetChildren( children );

    Resources::const_iterator iter = m_resources.begin();
    Resources::const_iterator end  = m_resources.end();
    for ( ; iter != end; ++iter ) {
        cResource * r = iter->second;
        children.push_back( r );
    }
}

inline status wait_children(Children &cs) 
{ 
    BOOST_ASSERT(cs.size() >= 2); 

    typename Children::iterator it = cs.begin(); 
    while (it != cs.end()) 
    { 
        const status s = it->wait(); 
        ++it; 
        if (it == cs.end()) 
            return s; 
        else if (!s.exited() || s.exit_status() != EXIT_SUCCESS) 
        { 
            while (it != cs.end()) 
            { 
                it->wait(); 
                ++it; 
            } 
            return s; 
        } 
    } 

    BOOST_ASSERT(false); 
    return cs.begin()->wait(); 
} 

int main () {
    Component* composite1 = new Composite();

    composite1->add( GET("LeafA") );
    composite1->add( GET("LeafA") );
    
    Component* composite2 = new Composite();
    composite2->add( GET("LeafB") );
    composite2->add( GET("LeafA") );
    composite2->add( composite1 );
    composite2->draw(10);

    Children* children = composite2->getChildren();

    std::cout << std::endl;
    int i = 11;
    for(typename Children::iterator it = children->begin(); it != children->end(); ++it) {
        (*it)->draw(i);
        i += 11;
    }
    return 0;
}

void Panel::RemoveAllChildren()
{
    Children aspChildren = m_aspChildren;
    for ( Children::iterator it = aspChildren.begin(); it != aspChildren.end(); ++it )
    {
        GuiObjectPtr spChild = *it;
        DeinitChild( spChild );
    }
    m_aspChildren.clear();
    
    if ( GetSizeModeX() == SIZE_MODE_CONTENT ||
         GetSizeModeY() == SIZE_MODE_CONTENT )
    {
        UpdateSize();
    }
     
    // Dispatch events   
    for ( Children::iterator it = aspChildren.begin(); it != aspChildren.end(); ++it )
    {
        GuiObjectPtr spChild = *it;
        DispatchEvent( EVENT_PANEL_CHILD_REMOVED, GetSharedPtr< Panel >(), spChild );
        DispatchEvent( EVENT_PANEL_CHILDREN_CHANGED, GetSharedPtr< Panel >(), spChild );
    }
}

void Entity::onObjectLoaded()
{
    __super::onObjectLoaded();

    if ( m_parent )
    {
        onAttached( *m_parent );
    }

    // copy the managed children to the runtime children array
    unsigned int count = m_managedChildren.size();
    m_children.resize( count );
    for( unsigned int i = 0; i < count; ++i )
    {
        m_children[i] = m_managedChildren[i];
    }

    // inform that the children have been attached
    Children children = m_children;
    for ( Children::iterator it = children.begin(); it != children.end(); ++it )
    {
        onChildAttached( **it );
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
	//知识点：注意区分指针类型(编译时确定)和对象类型(运行时确定). 总之，非虚方法是根据指针类型来调用，虚方法是根据对象类型来调用
	//指针类型(CBase)    对象类型(CDerived())
	//CBase *pBase = new CDerived();
	CBase base;
	cout << "sizeof(base):" << sizeof(base) << endl; // 4
	cout << sizeof(long long) << endl;
	//base.Test();

	CDerived derived;
	cout << "sizeof(derived):" << sizeof(derived) << endl;
	derived.name();
	derived.derived_print();
	CBase* p = &derived; //隐式向上强制转换
	//当一个derived class object被交出去当作一个base class object时，
	//它原本所以“成为一个derived class object”的所有特征，都会被切除（slicing）掉，只留下内部一个base class object。
	//以by reference的方式传递参数，有另一个优点：可避免所谓的“切割（slicing）问题”。引用是除指针外另一个可以产生多态效果的手段。
	Test1(derived);//Output from CBase! 出现切割
	Test2(derived);//Output from CDerived!
	Test3(p);      //Output from CDerived!
	cout << "打印指针自身内存地址:" << &p << endl; 
	cout << "打印指针指向内存地址:" << (int *)p << endl;
	p->show();
	//p->range();//编译错误.“range”: 不是“CBase”的成员

	CDerived* derived2 = (CDerived *)&base; //显式向下强制转换
	derived2->range();//调用派生类独有的方法，不安全操作（如果方法内有访问CDerived独有的成员变量，用到this指针就会出问题）
	CDerived* derived3 = dynamic_cast<CDerived*>(&base);//用dynamic_cast来转换类型可以检查转换是否安全成功，失败返回空指针
	if (derived3)
	{
		cout<< "derived3 dynamic_cast successful !!" <<endl;
		derived3->range();
	}
	else
	{
		cout<< "derived3 dynamic_cast failed !!" <<endl;
	}
	CDerived* derived4 = dynamic_cast<CDerived*>(p);
	if (derived4)
	{
		cout<< "derived4 dynamic_cast successful !!" <<endl;
		derived4->range();
	}
	else
	{
		cout<< "derived4 dynamic_cast failed !!" <<endl;
	}
	derived2->Test();//Output from CBase （根据对象类型来判断）
	
	CBase *pBase = new CDerived();
	/*虚析构：
	如果一个类用作基类，我们通常需要virtual来修饰它的析构函数，这点很重要。
	如果基类的析构函数不是虚析构，当我们用delete来释放基类指针(它其实指向的是派生类的对象实例)占用的内存的时候，
	只有基类的析构函数被调用，而派生类的析构函数不会被调用，这就可能引起内存泄露。如果基类的析构函数是虚析构，
	那么在delete基类指针时，继承树上的析构函数会被自低向上依次调用，即最底层派生类的析构函数会被首先调用，
	然后一层一层向上直到该指针声明的类型。*/
	delete pBase;

	Person *person = new Person();
	person->showAge();
	person->show1();
	printf("%d\n", Person::date);
	Children *children = new Children();
	printf("%d\n", Children::date);
	children->show1();
	Person *person1 = children;
	//show2()没有使用virtual关键字，程序将根据引用或者指针类型选择方法。忠告：绝对不要重新定义继承而来的非虚拟函数
	person1->show2(); //Person::show2()
	Children* children2 = (Children*)person;//显式向下强制转换
	children2->show2(); //Children::show2()  发现转型之后还是可以调用Children的函数的，因为编译的时函数内存地址已经确定，如果函数里面需要用到this指针调用到成员变量就不安全
	Person *person2 = new Children();
	//person2->show4(); person2并不能调用show4()，只能调用Person类方法;
	person2->hide();
	//children->hide(); //Person的hide()函数给隐藏了,不能调用
	children->hide(1);

	//子类在外部调用父类方法！！！！好奇怪的语法
	Children child;
	child.Person::show2();
	Children *pChild = new Children();
	pChild->Person::show2();

	//测试覆盖
	person1->testOverride(10);
	person2->testOverride(10);
	children->testOverride(10);
	system("Pause");
	return 0;
}

void start()
{
    std::ofstream pidfile(SC_PID);
    if (!pidfile.good()) {
        std::cerr << "cannot open PID file " << SC_PID << ": " << strerror(errno) << std::endl;
        exit(errno);
    }
    pidfile << getpid() << std::endl;
    pidfile.close();

    std::ofstream log;

    log.open(SC_LOG, std::ofstream::app);
    log << "\n"
        << logPrefix() << "starting shoutcast daemon" << std::endl;
    log << logPrefix() << "reading shoutcast configuration files from " << SC_CONFIG << std::endl;
    log.close();

    // Enumerate config files in shoutcast config dir.
    DIR *dir;
    struct dirent *ent;
    dir = opendir (SC_CONFIG);
    if (dir == NULL) {
        log.open(SC_LOG, std::ofstream::app);
        log << logPrefix() << "cannot read scd configuration direcoty " << SC_CONFIG << ": " << strerror(errno) << std::endl;
        log.close();
        exit(errno);
    }

    for (; ent = readdir(dir); ent != NULL) {
        std::string cfgfile = ent->d_name;
        if (cfgfile == "." || cfgfile == "..") {
            continue;
        }
        std::string cfgpath = SC_CONFIG;
        cfgpath += "/";
        cfgpath += cfgfile;
        Child c;
        c.pid = 0;
        c.config = cfgpath;
        size_t idx = cfgfile.find(".");
        c.log = SC_LOGDIR"sc_stream_";
        c.log += cfgfile.substr(0, idx);
        c.log += ".log";
        g_children.push_back(c);

        log.open(SC_LOG, std::ofstream::app);
        log << logPrefix() << "found shoutcast configuration: " << cfgpath << std::endl;
        log.close();
    }
    closedir(dir);

    // Start respawn loop.
    while (g_running) {
        // Respawn all children with zero pid.
        for (Children::iterator i = g_children.begin();
                i != g_children.end(); ++i) {
            if (i->pid == 0) {
                i->pid = fork();
                if (i->pid == 0) {
                    // Open log file and redirect stdout, stderr.
                    FILE *f = fopen(i->log.c_str(), "a");
                    int r1 = dup2(fileno(f), 1);
                    int r2 = dup2(fileno(f), 2);
                    fclose(f);

                    // Start child process.
                    std::cout << timeStr()
                              << "[" << getpid() << "] started"
                              << std::endl;
                    if (execl(SC_EXEC, SC_EXEC, i->config.c_str(),
                            (char*)0) < 0) {
                        exit(1);
                    }
                } else {
                    log.open(SC_LOG, std::ofstream::app);
                    log << logPrefix() << "spawned server for config " << i->config << ", server pid is [" << i->pid << "]" << std::endl;
                    log.close();
                }
            }
        }

        // Wait for any failed children.
        int status;
        pid_t pid = wait(&status);
        if (!g_running)
            break;

        // Mark a failed child to restart.
        for (Children::iterator i = g_children.begin(); i != g_children.end(); ++i) {
            if (i->pid == pid) {
                log.open(SC_LOG, std::ofstream::app);
                log << logPrefix() << "server with pid [" << pid << "] (" << i->config << ") failed with status " << status << std::endl;
                log.close();
                i->pid = 0;
                break;
            }
        }
    }

//.........这里部分代码省略.........

 size_t outdegree() const {
     return children.size();
 }