C++ array::end方法代码示例

/** Evaluates and executes a dvisvgm special statement.
 *  @param[in] prefix special prefix read by the SpecialManager
 *  @param[in] is the special statement is read from this stream
 *  @param[in] actions object providing the actions that can be performed by the SpecialHandler */
bool DvisvgmSpecialHandler::process (const string &prefix, istream &is, SpecialActions &actions) {
	struct Command {
		const char *name;
		void (DvisvgmSpecialHandler::*handler)(InputReader&, SpecialActions&);
	};
	constexpr array<Command, 7> commands {{
		{"raw",       &DvisvgmSpecialHandler::processRaw},
		{"rawdef",    &DvisvgmSpecialHandler::processRawDef},
		{"rawset",    &DvisvgmSpecialHandler::processRawSet},
		{"endrawset", &DvisvgmSpecialHandler::processEndRawSet},
		{"rawput",    &DvisvgmSpecialHandler::processRawPut},
		{"bbox",      &DvisvgmSpecialHandler::processBBox},
		{"img",       &DvisvgmSpecialHandler::processImg}
	}};
	StreamInputReader ir(is);
	const string cmdstr = ir.getWord();
	auto it = find_if(commands.begin(), commands.end(), [&](const Command &cmd) {
		return cmd.name == cmdstr;
	});
	if (it != commands.end()) {
		ir.skipSpace();
		(this->*it->handler)(ir, actions);
	}
	return true;
}

void anagram(array<string,sz> &arrStr){
//	for_each( arrStr.begin(), arrStr.end(), myStrSort);
	for( auto & str : arrStr )
		sort( str.begin(), str.end() );
	sort( arrStr.begin(), arrStr.end() );

	std::cout << "\nAfter in-place sorting, arrStr contains:\n\n";
	for ( auto it = arrStr.begin(); it != arrStr.end(); ++it )
		std::cout << ' ' << *it;
	std::cout << endl;
}

BOOST_AUTO_TEST_CASE_TEMPLATE( real_valued, T, real_types )
{
    array<T,3> x = {{ 1, 2, 3 }};
    array<T,3> y = {{ 4, 5, 6 }};
    blas::swap(x.size(), x.c_array(), 1, y.c_array(), 1);

    const array<T,3> x_expected = {{ 4, 5, 6 }};
    const array<T,3> y_expected = {{ 1, 2, 3 }};
    BOOST_CHECK_EQUAL_COLLECTIONS(
            x.begin(), x.end(), x_expected.begin(), x_expected.end());
    BOOST_CHECK_EQUAL_COLLECTIONS(
            y.begin(), y.end(), y_expected.begin(), y_expected.end());
}

int main() {
	size_t tCase;
	int tmp;
	in >> tCase;
	while (tCase--) {
		MaxResult = 0;
		SequenceNumber.clear();
		fill(DynamicMemory.begin(), DynamicMemory.end(), -1);
		in >> Seqnum;
		for (size_t i = 0; i < Seqnum;i ++) {
			in >> tmp;
			SequenceNumber.push_back(tmp);
		}
		for (size_t i = 0; i < Seqnum; i++) {
			if (DynamicMemory[i] == -1) LIS(SequenceNumber, i);
		}
		for (size_t i = 0; i < Seqnum; i++) {
			if (DynamicMemory[i] == -1) break;
			if (DynamicMemory[i] > MaxResult) {
				MaxResult = DynamicMemory[i];
			}
		}
		cout << MaxResult << endl;
	}

	return 0;
}

void copy_out(array<T, S>& out, const array<J, D>& in)
{
	CHECK(out.length() <= in.length(), erange);
	typename array<J, D>::const_iterator it_src = in.begin();
	typename array<T, S>::iterator it_end = out.end();
	typename array<T, S>::iterator it = out.begin();

	while (it != it_end) *it++ = *it_src++;
}

void copy(array<T, S>& out, const T& val,
		types::term as_element)
{
	typename array<T, S>::iterator it_end = out.end();
	typename array<T, S>::iterator it = out.begin();

	while (it != it_end)
		*(it++) = (val);
}

    void stop() {
        if ( !started_) return;
        started_ = false;
        sock_.close();

        ptr self = shared_from_this();
        array::iterator it = std::find(clients.begin(), clients.end(), self);
        clients.erase(it);
        update_clients_changed();
    }

		void copy(const array<T>& _ar){
			assign(_ar.size());
			const_iterator citr=_ar.begin(),cenditr=_ar.end();
			iterator itr=begin();
			while(citr!=cenditr){
				(*itr)=(*citr);
				++citr;
				++itr;
			}
		}

static void con_add_buffer_line(const con_priority priority, const char *const buffer, const size_t len)
{
	/* shift con_buffer for one line */
	std::move(std::next(con_buffer.begin()), con_buffer.end(), con_buffer.begin());
	console_buffer &c = con_buffer.back();
	c.priority=priority;

	size_t copy = std::min(len, CON_LINE_LENGTH - 1);
	c.line[copy] = 0;
	memcpy(&c.line,buffer, copy);
}

int main(int argc, char** argv)
{
	std::cout << "arrStr contains:\n";
	for ( auto it = arrStr.begin(); it != arrStr.end(); ++it )
		std::cout << ' ' << *it;
	std::cout << '\n';
	sortAnagram(arrStr);
	anagram(arrStr);

    return 0;
}

    int main(std::string __name__) {
        sub::main("sub");
        #define sub SUB
        sub2::main("sub2");
        _var_a_ = (array<int, 2>){2, 3};
        b = std::vector<int>(_var_a_.begin(), _var_a_.end());
        _var_b_ = (array<array<int, 2>, 2>){ 4, 5 ,  6, 7 };
        c = std::vector<array<int, 2> >(_var_b_.begin(), _var_b_.end());
        _var_c_ = (array<int, 2>){9, 10};
        d = (_type_a_){8, std::vector<int>(_var_c_.begin(), _var_c_.end())};
        _var_d_ = (array<_type_a_, 2>){d, d};
        e = std::vector<_type_a_>(_var_d_.begin(), _var_d_.end());
        _var_e_ = (array<int, 2>){1, 2};
        _var_f_ = std::vector<int>(_var_e_.begin(), _var_e_.end());
        f = _var_f_[0];
        g = _var_f_[1];
        _var_g_ = (array<int, 2>){3, 4};
        _var_h_ = (_type_b_){std::vector<int>(_var_g_.begin(), _var_g_.end()), 5};
        h = _var_h_._0;
        i = _var_h_._1;
        _var_i_ = (_type_b_){h, i};
        _var_j_ = _var_i_._0;
        j = _var_j_[0];
        k = _var_j_[1];
        m = _var_i_._1;
        fun(0);
        #undef SUB

        return 0;
    }

int main()
{
	int tests;
	int citiesN;
	int relationsN;
	int paths;
	string name;
	cin >> tests;

	for (int t = 0; t < tests; t++)
	{
		cityId.clear();
		graph.clear();
		cin >> citiesN;
		for(int c = 1; c <= citiesN; c++)
		{
			distances[c] = infinity;
			emptyDistances[c] = infinity;

			city city;
			cin >> city.name;
			graph[c] = city;
			cityId[city.name] = c;
			cin >> relationsN;

			for(int r = 0; r < relationsN; r++)
			{
				way way1;
				cin >> way1.destination >> way1.cost;
				graph[c].adjacent.push_back(way1);
				way way2 = way1;
				way2.destination = c;
				graph[way2.destination].adjacent.push_back(way2);
			}

		}

		cin >> paths;

		for (int p = 0; p < paths; p++)
		{
			string source, destination;
			cin >> source >> destination;
			distances = emptyDistances;
			fill(visited.begin(), visited.end(), false);
			dijkstra(cityId[source], cityId[destination]);
			cout << distances[cityId[destination]] << endl;
		}
	}
	
	return 0;
}

    __agency_exec_check_disable__
    __AGENCY_ANNOTATION
    array(const array& other)
      : array(other.shape())
    {
      auto iter = other.begin();
      auto result = begin();

      for(; iter != other.end(); ++iter, ++result)
      {
        *result = *iter;
      }
    }

void sort_edges(array<iPair,4>& marker) {
  /* y has the lowest y-coordinate (top left), stick it
     at the end of the list */
  sort(marker.begin(), marker.end()
       , [](const iPair &a, const iPair &b) {
	 return a.y > b.y;
       });

  /* Sorting green blobs - if marker[0] has a greater X value,
   * it's not the origin so swap it around */
  if(marker[0].x > marker[1].x) swap(marker[0], marker[1]);
  if(marker[2].x > marker[3].x) swap(marker[2], marker[3]);
}

static void readDouble(const File& file,
                       const string& name,
                       const array<size_t, dimension>& start,
                       const array<size_t, dimension>& count,
                       Type* values,
                       PropertyType Type::*property,
                       const Converter& converter) {
    size_t size = accumulate(count.begin(), count.end(), 1, [](size_t n, size_t m) { return n*m; });
    vector<double> v(size);
    const Var var(file.var(name));
    var.get(start, count, v.data());
    size_t n = 0;
    for (auto it = v.begin(); it != v.end(); ++it, ++n) {
        values[n].*property = converter(*it);
    }
}