C++ (Cpp) array::add Examples

Programming Language: C++ (Cpp)

Class/Type: array

Method/Function: add

Examples at hotexamples.com: 4

C++ has an array data type that allows storing elements of the same data type in a linear fashion. To add elements to an array in C++, you need to specify the index of the element where you want to add the value. Here are some code examples in C++ that demonstrate array add:

1. Adding values to an array using a for loop:

int arr[5];
for(int i=0; i<5; i++){
    arr[i] = i+1;
}

This code creates an integer array of size 5 and adds values from 1 to 5 to each index using a for loop.

2. Adding values to an array using a function:

void addValue(int arr[], int index, int value){
    arr[index] = value;
}

int main(){
    int arr[5];
    addValue(arr, 0, 10);
    addValue(arr, 4, 20);
}

This code creates an integer array of size 5 and adds values 10 and 20 to index 0 and 4 respectively using a function. The C++ standard library provides an array container in the header file that makes handling arrays easier and provides added functionality such as bounds checking, range-based iteration, etc. However, the above examples do not use any package library and are pure C++.

C++ (Cpp) array::add - 4 examples found. These are the top rated real world C++ (Cpp) examples of array::add from package PDAL extracted from open source projects. You can rate examples to help us improve the quality of examples.

Frequently Used Methods

Show Hide

get(30)

end(30)

begin(30)

dims(25)

data(17)

back(10)

append(8)

clear(6)

empty(6)

at(6)

fill(4)

add(4)

eval(4)

elements(3)

copy(3)

cend(3)

assign(3)

cbegin(3)

count(2)

derived(2)

find(2)

get_key_at_id(2)

get_buffer(1)

get_dim_size(1)

getSize(1)

get_dtype(1)

front(1)

get_element(1)

get_extent(1)

T(1)

fetch_ref(1)

erase(1)

emplace_back(1)

eager_slice(1)

dump(1)

_storage(1)

cdata(1)

c_ptr(1)

attach(1)

at_array(1)

_storage_size(1)

drop(1)

Example #1

Show file

File: maplayers.cpp Project: Redix/teeworlds

void CMapLayers::LoadEnvPoints(const CLayers *pLayers, array<CEnvPoint>& lEnvPoints)
{
	lEnvPoints.clear();

	// get envelope points
	CEnvPoint *pPoints = 0x0;
	{
		int Start, Num;
		pLayers->Map()->GetType(MAPITEMTYPE_ENVPOINTS, &Start, &Num);

		if(!Num)
			return;

		pPoints = (CEnvPoint *)pLayers->Map()->GetItem(Start, 0, 0);
	}

	// get envelopes
	int Start, Num;
	pLayers->Map()->GetType(MAPITEMTYPE_ENVELOPE, &Start, &Num);
	if(!Num)
		return;


	for(int env = 0; env < Num; env++)
	{
		CMapItemEnvelope *pItem = (CMapItemEnvelope *)pLayers->Map()->GetItem(Start+env, 0, 0);

		if(pItem->m_Version >= 3)
		{
			for(int i = 0; i < pItem->m_NumPoints; i++)
				lEnvPoints.add(pPoints[i + pItem->m_StartPoint]);
		}
		else
		{
			// backwards compatibility
			for(int i = 0; i < pItem->m_NumPoints; i++)
			{
				// convert CEnvPoint_v1 -> CEnvPoint
				CEnvPoint_v1 *pEnvPoint_v1 = &((CEnvPoint_v1 *)pPoints)[i + pItem->m_StartPoint];
				CEnvPoint p;

				p.m_Time = pEnvPoint_v1->m_Time;
				p.m_Curvetype = pEnvPoint_v1->m_Curvetype;

				for(int c = 0; c < pItem->m_Channels; c++)
				{
					p.m_aValues[c] = pEnvPoint_v1->m_aValues[c];
					p.m_aInTangentdx[c] = 0;
					p.m_aInTangentdy[c] = 0;
					p.m_aOutTangentdx[c] = 0;
					p.m_aOutTangentdy[c] = 0;
				}

				lEnvPoints.add(p);
			}
		}
	}
}

Example #2

Show file

File: hash_counter.hpp Project: dfajar2/KAT

  /// Add `v` to the entry `k`. It returns in `is_new` true if the
  /// entry `k` did not exist in the hash. In `id` is returned the
  /// final position of `k` in the hash array.
  void add(const Key& k, uint64_t v, bool* is_new, size_t* id) {
    unsigned int carry_shift  = 0;
    bool*        is_new_ptr   = is_new;
    size_t*      id_ptr       = id;
    bool         is_new_void  = false;
    size_t       id_void      = false;

    while(!ary_->add(k, v, &carry_shift, is_new_ptr, id_ptr)) {
      handle_full_ary();
      v &= ~(uint64_t)0 << carry_shift;
      // If carry_shift == 0, failed to allocate the first field for
      // key, hence status of is_new and value for id are not
      // determined yet. On the other hand, if carry_shift > 0, we
      // failed while adding extra field for large key, so the status
      // of is_new and value of id are known. We do not update them in future
      // calls.
      if(carry_shift) {
        is_new_ptr = &is_new_void;
        id_ptr     = &id_void;
      }
    }
  }

Example #3

Show file

File: StringArray.cpp Project: moorecoin/MooreCoinService

 void addarray (array<string>& dest, const type* const strings, const int numberofstrings)
 {
     for (int i = 0; i < numberofstrings; ++i)
         dest.add (strings [i]);
 }

Example #4

Show file

File: StringArray.cpp Project: moorecoin/MooreCoinService

 void addarray (array<string>& dest, const chartype* const* strings)
 {
     if (strings != nullptr)
         while (*strings != nullptr)
             dest.add (*strings++);
 }