自学教程：C++ Element函数代码示例

  Space operator()( int color )  {    Space base, sub, margin;    for ( typename Space::const_iterator it = base_.begin()        ; it != base_.end(); ++it        )    {      typename Space::const_point pt( it );      if ( color_[ pt.index ] == color ) base.join( pt.element );    }    for ( typename Space::const_iterator it = base.begin()        ; it != base.end(); ++it        )    {      typename Space::const_point pt0( it );#ifdef ELAI_USE_C11      const Space&& adj = std::move( adjacent_( pt0.element ) );#else      const Space adj = adjacent_( pt0.element );#endif      sub.join( Element( pt0.element, color ) );      for ( typename Space::const_iterator jt = adj.begin()          ; jt != adj.end(); ++jt          )      {        typename Space::const_point pt( jt );        if ( base.contain( pt.element ) || margin.contain( Element( pt.element, color ) ) ) continue;        int c = color_[ base_.index( pt.element ) ];        margin.join( Element( pt.element, color ), Element( pt.element, c ) );      }    }    return sub | margin;  }

NS_IMETHODIMPDOMSVGPathSegList::RemoveItem(PRUint32 aIndex,                              nsIDOMSVGPathSeg **_retval){    *_retval = nsnull;    if (IsAnimValList()) {        return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;    }    if (aIndex >= Length()) {        return NS_ERROR_DOM_INDEX_SIZE_ERR;    }    // We have to return the removed item, so make sure it exists:    EnsureItemAt(aIndex);    // Notify the DOM item of removal *before* modifying the lists so that the    // DOM item can copy its *old* value:    ItemAt(aIndex)->RemovingFromList();    NS_ADDREF(*_retval = ItemAt(aIndex));    PRUint32 internalIndex = mItems[aIndex].mInternalDataIndex;    PRUint32 segType = SVGPathSegUtils::DecodeType(InternalList().mData[internalIndex]);    PRUint32 argCount = SVGPathSegUtils::ArgCountForType(segType);    // Now that we know we're removing, keep animVal list in sync as necessary.    // Do this *before* touching InternalList() so the removed item can get its    // internal value.    MaybeRemoveItemFromAnimValListAt(aIndex, argCount);    InternalList().mData.RemoveElementsAt(internalIndex, 1 + argCount);    mItems.RemoveElementAt(aIndex);    UpdateListIndicesFromIndex(aIndex, -(argCount + 1));    Element()->DidChangePathSegList(true);    if (AttrIsAnimating()) {        Element()->AnimationNeedsResample();    }    return NS_OK;}

// Reduces all elements in a column except the diagonal element// Returns 0 on success, 1 if the column cannot be reducedint Matrix::ReduceColumn(int column, Matrix &inverse){	// loop variable for working down column	int row, pivot = column;	// find the first non-zero element in the column	// that is not above the diagonal	for (row = pivot; row < 4; row++)		if (fabs(Element(row, pivot)) > ERROR_TOLERANCE)			break;	// if we didn't find one, return an error code	if (row == 4) return 1;	// if we did, but it wasn't on the diagonal, swap with the pivot row	// this makes sure we never get divide by zero errors	if (row != pivot)	{		SwapRows(pivot, row);		inverse.SwapRows(pivot, row);	}	// now scale the pivot row so the pivot element is one	float scaleFactor = 1.0 / Element(pivot, pivot);	ScaleRow(pivot, scaleFactor);	inverse.ScaleRow(pivot, scaleFactor);	// for each row	for (row = 0; row < 4; row++)	{		// skip the row we're pivoting on		if (row == column) continue;		scaleFactor = -Element(row, pivot);		AddRows(row, scaleFactor, pivot);		inverse.AddRows(row, scaleFactor, pivot);	}	// and we're done	return 0;}

void IceLiveRange::addSegment(int Start, int End) {#ifdef USE_SET  RangeElementType Element(Start, End);  RangeType::iterator Next = Range.lower_bound(Element);  assert(Next == Range.upper_bound(Element)); // Element not already present  // Beginning of code that merges contiguous segments.  TODO: change  // "if(true)" to "if(false)" to see if this extra optimization code  // gives any performance gain, or is just destabilizing.  if (true) {    RangeType::iterator FirstDelete = Next;    RangeType::iterator Prev = Next;    bool hasPrev = (Next != Range.begin());    bool hasNext = (Next != Range.end());    if (hasPrev)      --Prev;    // See if Element and Next should be joined.    if (hasNext && End == Next->first) {      Element.second = Next->second;      ++Next;    }    // See if Prev and Element should be joined.    if (hasPrev && Prev->second == Start) {      Element.first = Prev->first;      FirstDelete = Prev;    }    Range.erase(FirstDelete, Next);  }  // End of code that merges contiguous segments.  Range.insert(Next, Element);#else  if (Range.empty()) {    Range.push_back(RangeElementType(Start, End));    return;  }  // Special case for faking in-arg liveness.  if (End < Range.front().first) {    assert(Start < 0);    Range.push_front(RangeElementType(Start, End));    return;  }  int CurrentEnd = Range.back().second;  assert(Start >= CurrentEnd);  // Check for merge opportunity.  if (Start == CurrentEnd) {    Range.back().second = End;    return;  }  Range.push_back(RangeElementType(Start, End));#endif}

void SparseMatrix::set_element_at(int i, int j, double n){    Element temp = Element(j,n);    bool exist = false;    DListNode<Element> *trav = row(i).getFirst();    while(trav != NULL && trav != row(i).getAfterLast()){        if(trav->getElem().col == j){            exist = true;            trav->getElemRef()->setVal(n);        }        trav = trav->getNext();    }    if(!exist) row(i).insertLast(temp);}

    void Train(InputType& data, OutputType& target)    {      // Reset the training error.      trainingError = 0;      for (size_t i = 0; i < index.n_elem; i++)      {        net.FeedForward(Element(data, index(i)),            Element(target, index(i)), error);        trainingError += net.Error();        net.FeedBackward(error);        if (((i + 1) % batchSize) == 0)          net.ApplyGradients();      }      if ((index.n_elem % batchSize) != 0)        net.ApplyGradients();      trainingError /= index.n_elem;    }

already_AddRefed<SVGTransform>DOMSVGTransformList::IndexedGetter(uint32_t index, bool& found,                                   ErrorResult& error){  if (IsAnimValList()) {    Element()->FlushAnimations();  }  found = index < LengthNoFlush();  if (found) {    return GetItemAt(index);  }  return nullptr;}

int CUtlVector<T, A>::InsertBefore(int elem, const T& src){    // Can't insert something that's in the list... reallocation may hose us    assert((Base() == NULL) || (&src < Base()) || (&src >= (Base() + Count())));    // Can insert at the end    assert((elem == Count()) || IsValidIndex(elem));    GrowVector();    ShiftElementsRight(elem);    CopyConstruct(&Element(elem), src);    return elem;}

void Write_Node(TreeNode Node){   int i;   for (i=1; i <= Rank(Node); i++)      Write_Node(Child(Node, i));   Write_String(Tree_File, NodeName(Node));   fprintf(Tree_File,"/n");   Write_String(Tree_File, SourceLocation(Node));   fprintf(Tree_File,"/n");   fprintf(Tree_File,"%1d/n", Element(Tree,Node+2));}

TreeNode Decoration(TreeNode T){   int Neg;   int Value;   Value = Element(Tree,T+2);   Neg = Value < 0;   if (Neg)       return -(abs(Value) / 1000);   else       return Value / 1000;}

void Decorate(TreeNode T1, TreeNode T2){   int Neg;   int NewValue;   Neg = (T2 < 0);   NewValue = abs(Element(Tree, T1+2)) % 1000 + abs(T2) * 1000;   if (Neg)       Assign(Tree, T1 + 2, -NewValue);   else       Assign(Tree, T1 + 2, NewValue);}

void CAI_InterestTarget::Add( CAI_InterestTarget_t::CAI_InterestTarget_e type, CBaseEntity *pTarget, const Vector &vecPosition, float flImportance, float flDuration, float flRamp ){	int i = AddToTail();	CAI_InterestTarget_t &target = Element( i );	target.m_eType = type;	target.m_hTarget = pTarget;	target.m_vecPosition = vecPosition;	target.m_flInterest = flImportance;	target.m_flStartTime = gpGlobals->curtime;	target.m_flEndTime = gpGlobals->curtime + flDuration;	target.m_flRamp = flRamp / flDuration;}

void DESolver::Rand2Bin(int candidate){	int r1, r2, r3, r4, r5;	int n;	SelectSamples(candidate,&r1,&r2,&r3,&r4,&r5);	n = (int)RandomUniform(0.0,(double)nDim);	CopyVector(trialSolution,RowVector(population,candidate));	for (int i=0; i < nDim; i++) 	{		if ((RandomUniform(0.0,1.0) < probability) || (i  == (nDim - 1)))			trialSolution[n] = Element(population,r1,n)								+ scale * (Element(population,r2,n)											+ Element(population,r3,n)											- Element(population,r4,n)											- Element(population,r5,n));		n = (n + 1) % nDim;	}	return;}

void DOMSVGLength::SetValue(float aUserUnitValue, ErrorResult& aRv) {  if (mIsAnimValItem) {    aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);    return;  }  if (mVal) {    aRv = mVal->SetBaseValue(aUserUnitValue, mSVGElement, true);    return;  }  // Although the value passed in is in user units, this method does not turn  // this length into a user unit length. Instead it converts the user unit  // value to this length's current unit and sets that, leaving this length's  // unit as it is.  if (HasOwner()) {    if (InternalItem().GetValueInUserUnits(Element(), Axis()) ==        aUserUnitValue) {      return;    }    float uuPerUnit = InternalItem().GetUserUnitsPerUnit(Element(), Axis());    if (uuPerUnit > 0) {      float newValue = aUserUnitValue / uuPerUnit;      if (IsFinite(newValue)) {        AutoChangeLengthNotifier notifier(this);        InternalItem().SetValueAndUnit(newValue, InternalItem().GetUnit());        return;      }    }  } else if (mUnit == SVGLength_Binding::SVG_LENGTHTYPE_NUMBER ||             mUnit == SVGLength_Binding::SVG_LENGTHTYPE_PX) {    mValue = aUserUnitValue;    return;  }  // else [SVGWG issue] Can't convert user unit value to this length's unit  // ReportToConsole  aRv.Throw(NS_ERROR_FAILURE);}

uint16_t DOMSVGLength::UnitType() {  if (mVal) {    if (mIsAnimValItem) {      mSVGElement->FlushAnimations();    }    return mVal->mSpecifiedUnitType;  }  if (mIsAnimValItem && HasOwner()) {    Element()->FlushAnimations();  // May make HasOwner() == false  }  return HasOwner() ? InternalItem().GetUnit() : mUnit;}

Element ByteGroup::Inverse(const Element &a) const{    const QByteArray ba = GetByteArray(a);    QByteArray out(ba.count(), 0);    const int c = ba.count();    for(int i=0; i<c; i++) {        out[i] = !ba[i];    }    return Element(new ByteElementData(out));}

xlw::XlfOper4& xlw::XlfOper4::Set(const MyMatrix& values){    if (values.size1() ==0 || values.size2() ==0)    {        return *this;    }    CellMatrix tmp(values.size1(), values.size2());    for (unsigned long i=0; i < values.size1(); i++)        for (unsigned long j=0; j < values.size2(); j++)            tmp(i,j) = Element(values,i,j);    return Set(tmp);}

already_AddRefed<nsISVGPoint>DOMSVGPointList::IndexedGetter(uint32_t aIndex, bool& aFound,                               ErrorResult& aError){  if (IsAnimValList()) {    Element()->FlushAnimations();  }  aFound = aIndex < LengthNoFlush();  if (aFound) {    return GetItemAt(aIndex);  }  return nullptr;}

already_AddRefed<nsISVGPoint>DOMSVGPointList::ReplaceItem(nsISVGPoint& aNewItem, uint32_t aIndex,                             ErrorResult& aError){  if (IsAnimValList()) {    aError.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);    return nullptr;  }  if (aIndex >= LengthNoFlush()) {    aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);    return nullptr;  }  nsCOMPtr<nsISVGPoint> domItem = &aNewItem;  if (domItem->HasOwner() || domItem->IsReadonly()) {    domItem = domItem->Clone(); // must do this before changing anything!  }  nsAttrValue emptyOrOldValue = Element()->WillChangePointList();  if (mItems[aIndex]) {    // Notify any existing DOM item of removal *before* modifying the lists so    // that the DOM item can copy the *old* value at its index:    mItems[aIndex]->RemovingFromList();  }  InternalList()[aIndex] = domItem->ToSVGPoint();  mItems[aIndex] = domItem;  // This MUST come after the ToSVGPoint() call, otherwise that call  // would end up reading bad data from InternalList()!  domItem->InsertingIntoList(this, aIndex, IsAnimValList());  Element()->DidChangePointList(emptyOrOldValue);  if (AttrIsAnimating()) {    Element()->AnimationNeedsResample();  }  return domItem.forget();}

NS_IMETHODIMPDOMSVGLengthList::Clear(){  if (IsAnimValList()) {    return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;  }  if (Length() > 0) {    // Notify any existing DOM items of removal *before* truncating the lists    // so that they can find their SVGLength internal counterparts and copy    // their values. This also notifies the animVal list:    mAList->InternalBaseValListWillChangeTo(SVGLengthList());    mItems.Clear();    InternalList().Clear();    Element()->DidChangeLengthList(AttrEnum(), true);    if (mAList->IsAnimating()) {      Element()->AnimationNeedsResample();    }  }  return NS_OK;}

void RecipeMLImporter::readRecipemlSrcItems( const QDomElement& sources ){    QDomNodeList l = sources.childNodes();    for ( int i = 0 ; i < l.count(); i++ ) {        QDomElement srcitem = l.item( i ).toElement();        QString tagName = srcitem.tagName();        if ( tagName == "srcitem" )            recipe.authorList.append( Element( srcitem.text().trimmed() ) );        else            kDebug() << "Unknown tag within <source>: " << tagName ;    }}

bool MgWmsLayerDefinitions::GetElementContents(CPSZ pszElementName,STRING& sValue){    MgXmlSynchronizeOnElement Element(*m_xmlParser,pszElementName);    if(!Element.AtBegin())        return false;    if(m_xmlParser->Current().Type() == keText) {        sValue = m_xmlParser->Current().Contents();        return true;    }    return false;}

NS_IMETHODIMPDOMSVGNumberList::RemoveItem(PRUint32 index,                             nsIDOMSVGNumber **_retval){  *_retval = nsnull;  if (IsAnimValList()) {    return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;  }  if (index >= Length()) {    return NS_ERROR_DOM_INDEX_SIZE_ERR;  }  // Now that we know we're removing, keep animVal list in sync as necessary.  // Do this *before* touching InternalList() so the removed item can get its  // internal value.  MaybeRemoveItemFromAnimValListAt(index);  // We have to return the removed item, so make sure it exists:  EnsureItemAt(index);  // Notify the DOM item of removal *before* modifying the lists so that the  // DOM item can copy its *old* value:  mItems[index]->RemovingFromList();  NS_ADDREF(*_retval = mItems[index]);  InternalList().RemoveItem(index);  mItems.RemoveElementAt(index);  UpdateListIndicesFromIndex(mItems, index);  Element()->DidChangeNumberList(AttrEnum(), PR_TRUE);#ifdef MOZ_SMIL  if (mAList->IsAnimating()) {    Element()->AnimationNeedsResample();  }#endif  return NS_OK;}

NS_IMETHODIMPDOMSVGLengthList::ReplaceItem(nsIDOMSVGLength *newItem,                              PRUint32 index,                              nsIDOMSVGLength **_retval){  *_retval = nsnull;  if (IsAnimValList()) {    return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;  }  nsCOMPtr<DOMSVGLength> domItem = do_QueryInterface(newItem);  if (!domItem) {    return NS_ERROR_DOM_SVG_WRONG_TYPE_ERR;  }  if (index >= Length()) {    return NS_ERROR_DOM_INDEX_SIZE_ERR;  }  SVGLength length = domItem->ToSVGLength(); // get before setting domItem  if (domItem->HasOwner()) {    domItem = new DOMSVGLength();  }  if (mItems[index]) {    // Notify any existing DOM item of removal *before* modifying the lists so    // that the DOM item can copy the *old* value at its index:    mItems[index]->RemovingFromList();  }  InternalList()[index] = length;  domItem->InsertingIntoList(this, AttrEnum(), index, IsAnimValList());  mItems[index] = domItem;  Element()->DidChangeLengthList(AttrEnum(), PR_TRUE);#ifdef MOZ_SMIL  if (mAList->IsAnimating()) {    Element()->AnimationNeedsResample();  }#endif  NS_ADDREF(*_retval = domItem.get());  return NS_OK;}

NS_IMETHODIMPDOMSVGPointList::RemoveItem(PRUint32 aIndex,                            nsIDOMSVGPoint **_retval){  *_retval = nsnull;  if (IsAnimValList()) {    return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;  }  if (aIndex >= Length()) {    return NS_ERROR_DOM_INDEX_SIZE_ERR;  }  nsAttrValue emptyOrOldValue = Element()->WillChangePointList();  // Now that we know we're removing, keep animVal list in sync as necessary.  // Do this *before* touching InternalList() so the removed item can get its  // internal value.  MaybeRemoveItemFromAnimValListAt(aIndex);  // We have to return the removed item, so make sure it exists:  EnsureItemAt(aIndex);  // Notify the DOM item of removal *before* modifying the lists so that the  // DOM item can copy its *old* value:  mItems[aIndex]->RemovingFromList();  NS_ADDREF(*_retval = mItems[aIndex]);  InternalList().RemoveItem(aIndex);  mItems.RemoveElementAt(aIndex);  UpdateListIndicesFromIndex(mItems, aIndex);  Element()->DidChangePointList(emptyOrOldValue);  if (AttrIsAnimating()) {    Element()->AnimationNeedsResample();  }  return NS_OK;}

 /// /brief Inserts 'NewPath' into this trie. /c ConsumedLength denotes /// the number of /c NewPath's trailing characters already consumed during /// recursion. /// /// An insert of a path /// 'p'starts at the root node and does the following: /// - If the node is empty, insert 'p' into its storage and abort. /// - If the node has a path 'p2' but no children, take the last path segment ///   's' of 'p2', put a new child into the map at 's' an insert the rest of ///   'p2' there. /// - Insert a new child for the last segment of 'p' and insert the rest of ///   'p' there. /// /// An insert operation is linear in the number of a path's segments. void insert(StringRef NewPath, unsigned ConsumedLength = 0) {   // We cannot put relative paths into the FileMatchTrie as then a path can be   // a postfix of another path, violating a core assumption of the trie.   if (llvm::sys::path::is_relative(NewPath))     return;   if (Path.empty()) {     // This is an empty leaf. Store NewPath and return.     Path = NewPath;     return;   }   if (Children.empty()) {     // This is a leaf, ignore duplicate entry if 'Path' equals 'NewPath'.     if (NewPath == Path)         return;     // Make this a node and create a child-leaf with 'Path'.     StringRef Element(llvm::sys::path::filename(         StringRef(Path).drop_back(ConsumedLength)));     Children[Element].Path = Path;   }   StringRef Element(llvm::sys::path::filename(         StringRef(NewPath).drop_back(ConsumedLength)));   Children[Element].insert(NewPath, ConsumedLength + Element.size() + 1); }

/** * @brief MyArray::printSubarrayWithSumClose0 *Given an array contains positive and negative values, *find the subarray, whose sum is most closed to zero. Require nlogn time complexity * @param arr */void MyArray::printSubarrayWithSumClose0(vector<int> arr){    if (arr.empty()) return;    vector<Element> sumArray;    sumArray.push_back(Element(-1, 0));    int prev=0;    for (int i=0; i<arr.size(); i++)    {        int sum=arr[i]+prev;        sumArray.push_back(Element(i, sum));        prev=sum;    }    int start=0, last=0;    printSubArrayWithSumClose0_sub(sumArray, start, last);    cout << "SubArray is from " << start+1 << " to " << last << endl;    for (int i=start+1; i<=last; i++)        cout << arr[i] << " ";    cout << endl;}