C++ S1类代码示例

int main(int argc, char* argv[])
{
	Object* o = new Object();
	S1* s = new S1();
	const Class* c1 = s->GetClass();

	S1* s2 = c1->CreateInstance()->Cast<S1>();

	s->Cast<Object>();
 	s->Cast<B1>();
 	s->Cast<C1>();
	
	c1 = o->GetClass();
	B1* b = new B1();
	c1 = b->GetClass();
	

	g_objClassMap.add<Object>();
	g_objClassMap.add<B1>();
	g_objClassMap.add<B2>();
	g_objClassMap.add<S1>();
	g_objClassMap.add<C1>();
	B1* bb = (B1*)g_objClassMap.get<B1>()->CreateInstance();

	return 0;
}

void callmem() {
  S1 s;
  N(s.nospec());
  N(s.allspec());
  N(s.intspec());
  P(s.emptyspec());
}

void time_test(const S1& s1, const S2& s2, S3& s3, Op op, size_t n, size_t m) {
  typedef typename S1::iterator I;
  timer t;
  t.start();
  for (int i = 0; i < m; ++i)
    std::transform(s1.begin(), s1.end(), s2.begin(), s3.begin(), op);
  double time = t.stop()/(double(n) * m);
  std::cout << std::setw(6) << std::fixed << std::setprecision(2) << time << "\t";
}

int bar(int n){
  int a = 0;
  a += foo(n);
  S1 S;
  a += S.r1(n);
  a += fstatic(n);
  a += ftemplate<int>(n);

  return a;
}

int bar(int n, double *ptr) {
  int a = 0;
  a += foo(n, ptr);
  S1 S;
  a += S.r1(n);
  a += fstatic(n);
  a += ftemplate<int>(n);

  return a;
}

// CHECK: define {{.*}}@{{.*}}bar{{.*}}
int bar(int n){
  int a = 0;

  S1 S;
  // CHECK: call {{.*}}i32 [[FS1:@.+]]([[S1]]* {{.*}}, i32 {{.*}})
  a += S.r1(n);

  // CHECK: call {{.*}}i32 [[FSTATIC:@.+]](i32 {{.*}})
  a += fstatic(n);

  // CHECK: call {{.*}}i32 [[FTEMPLATE:@.+]](i32 {{.*}})
  a += ftemplate<int>(n);

  return a;
}

void Zombie::handleCollisionWith(GameObject* gameObject)
{
    if (this->hp<=0) {
        this->isScheduledForRemove = true;
    }
    S1* rabit = dynamic_cast<S1*>(gameObject);


    if (rabit != NULL) {
        xSpeed = 0;
        rabit->setHp(rabit->getHp()-this->atk);
        CCBAnimationManager* animationManager = dynamic_cast<CCBAnimationManager*>(this->getUserObject());
        animationManager->runAnimationsForSequenceNamed("attack");
    }
}

//////////////////////////////////////////////////////////////////////
// we have some const_casts here so we can get at the 
bool AddBoundListMatches(vector< pair<int, B1*> >& boundlist, const S1& fw, const I1& rg, int edgno, bool bGoingDown, bool bStartIn) 
{
    ASSERT(((edgno & 2) != 0) == bGoingDown);
    pair<int, int> ilr = fw.Loclohi(rg);
    
    // pull-back from any boundaries that just cross.
    if ((ilr.first <= ilr.second) && fw[ilr.first].blower && (fw[ilr.first].w == rg.lo))
        ilr.first++;
    if ((ilr.first <= ilr.second) && !fw[ilr.second].blower && (fw[ilr.second].w == rg.hi))
        ilr.second--;
        
    // deal with the inside/outside info
    ASSERT(fw.empty() || fw.front().blower);
    ASSERT(fw.empty() || !fw.back().blower);
    bool bLeftIn = (ilr.first == 0 ? false : fw[ilr.first - 1].blower);
    bool bRightIn = (ilr.second == (int)(fw.size()) - 1 ? false : !fw[ilr.second + 1].blower);
    ASSERT(bStartIn == (bGoingDown ? bRightIn : bLeftIn));
    bool bEndIn = (bGoingDown ? bLeftIn : bRightIn);

    // feed in the indexes of the entries
    if (!bGoingDown)
    {
        for (int i = ilr.first; i <= ilr.second; i++)
        {
            boundlist.push_back(pair<int, B1*>(edgno, const_cast<B1*>(&(fw[i]))));
            ASSERT(rg.Contains(fw[i].w));
        }
    }
    else
    {
        for (int i = ilr.second; i >= ilr.first; i--)
        {
            boundlist.push_back(pair<int, B1*>(edgno, const_cast<B1*>(&(fw[i]))));
            ASSERT(rg.Contains(fw[i].w));
        }
    }

    return bEndIn;
}

void fsvtkToolpathMapper::DrawFibre(S1& fib, I1& wrg, double z)
{
    glBegin(GL_LINE_STRIP);
    for (int i = 0; i < fib.size(); i++)
    {
        if ((i % 2) == 0)
        {
            glEnd();
            glBegin(GL_LINE_STRIP);
        }
        //P2 p = ((fib.value_type == 1) ? P2(fib[i].w, fib.wp) : P2(fib.wp, fib[i].w));
        P2 p = ((fib.ftype == 2) ? P2(fib[i].w, fib.wp) : P2(fib.wp, fib[i].w));
        glVertex3d(p.u, p.v, z);
    }

    glEnd();
}

void S2<T>::bar ()
{
  S1<T> st;
  st.foo();
}

 static typename boost::enable_if<storages::raw_copy_possible<S1,S2>, bool >::type
 rcp_impl(S1 & s1, S2 const & s2) {s1.raw_copy_from(s2); return true;}

static inline void set_difference(const S1 &src1, const S2 &src2, D &dst) {
	std::set_difference(
		src1.begin(), src1.end(), src2.begin(), src2.end(),
		std::inserter(dst, dst.begin()));
}

std::string
demo::__toString(const S1& arg)
{
  return "[" + arg.toString() + "]";
}

 S4() : s1(s1.baz()) {}

 inline int bbox(dim_t axis) const
 {
     return std::max((int)first_.bbox(axis), rest_.bbox(axis));
 }