C++ MyVector::size方法代码示例

MyVector<T> operator* (const MyVector<T>& a, const MyVector<T>& b){
   MyVector<T> result(a.size());
  for (std::size_t s= 0; s <= a.size(); ++s){
    result[s]= a[s]*b[s]; 
  }
  return result;
}

int main()
{
	// Create a default vector 
	MyVector sam;

	// push some data into sam
	cout << "\nPushing three values into sam";
	sam.push_back(TEST_VALUE1);
	sam.push_back(TEST_VALUE2);
	sam.push_back(TEST_VALUE3);

	cout << "\nThe values in sam are: ";

	// test for out of bounds condition here
	// and test exception 
	for (int i = 0; i < sam.size() + 1; i++)
	{
		try
		{
			cout << sam.at(i) << " ";
		}
		catch (int badIndex)
		{
			cout << "\nOut of bounds at index " << badIndex << endl;
		}
	}
	cout << "\n--------------\n";

	// clear sam and display its size and capacity
	sam.clear();
	cout << "\nsam has been cleared.";
	cout << "\nSam's size is now " << sam.size();
	cout << "\nSam's capacity is now " << sam.capacity() << endl;
	cout << "---------------\n";

	// Push 12 values into the vector - it should grow
	cout << "\nPush 12 values into sam.";
	for (int i = 0; i < MAX; i++)
		sam.push_back(i);

	cout << "\nSam's size is now " << sam.size();
	cout << "\nSam's capcacity is now " << sam.capacity() << endl;
	cout << "---------------\n";

	cout << "\nTest to see if contents are correct...";
	// display the values in the vector
	for (int i = 0; i < sam.size(); i++)
	{

		cout << sam.at(i) << " ";
	}
	cout << "\n--------------\n";

	cout << "\n\nTest Complete...";

	cout << endl;
	system("PAUSE");
	return 0;
}

void displayMyVector(MyVector& vec)
{
	printf("display my vector, vector size:%d\n", vec.size());
	for(unsigned int i = 0; i < vec.size(); i++)
	{
		Dynamic::Var var = vec.at(i);
		Poco::DynamicStruct ds = var.extract<DynamicStruct>();
		printf("Array[%u]:%s\n", i, ds.toString().c_str());
	}
}

//! Test concurrent invocations of method concurrent_vector::grow_by
void TestConcurrentGrowBy( int nthread ) {
    int m = 100000;
    MyVector v;
    tbb::parallel_for( tbb::blocked_range<int>(0,m,1000), GrowBy(v) );
    ASSERT( v.size()==size_t(m), NULL );

    // Verify that v is a permutation of 0..m
    int inversions = 0;
    bool* found = new bool[m];
    memset( found, 0, m );
    for( int i=0; i<m; ++i ) {
        int index = v[i].bar();
        ASSERT( !found[index], NULL );
        found[index] = true;
        if( i>0 )
            inversions += v[i].bar()<v[i-1].bar();
    }
    for( int i=0; i<m; ++i ) {
        ASSERT( found[i], NULL );
        ASSERT( nthread>1 || v[i].bar()==i, "sequential execution is wrong" );
    }
    delete[] found;
    if( nthread>1 && inversions<m/10 )
        std::printf("Warning: not much concurrency in TestConcurrentGrowBy\n");
}

 /**
  * Gets the total number of elements in the table.
  * @return the total number of elements in the table.
  */
 size_t totalSize() const {
     size_t k = 0;
     for (size_t i = 0; i < table.size(); ++i) {
         k += table[i].size();
     }
     return k;
 }

//..
// Finally, we demonstrate that the correct constructors are called when
// invoked with appropriate arguments:
//..
    void TestContainerConstructor()
    {
        const unsigned int TEST_DATA[] = { 1, 2, 3, 4, 5 };

        const MyVector<unsigned int> x(&TEST_DATA[0], &TEST_DATA[5]);
        const MyVector<unsigned int> y(13, 42);

        ASSERT(5 == x.size());
        for (int i = 0; i != 5; ++i) {
            ASSERT(TEST_DATA[i] == x[i]);
        }

        ASSERT(42 == y.size());
        for (int i = 0; i != 42; ++i) {
            ASSERT(13 == y[i]);
        }
    }

TEST(vector, size) {
	ASSERT_EQ(myvec.size(), vec.size());
	ASSERT_EQ(myvec.max_size(), vec.max_size());
	ASSERT_EQ(myvec.empty(), vec.empty());

	ASSERT_EQ(myempty_vec.size(), empty_vec.size());
	ASSERT_EQ(myempty_vec.max_size(), empty_vec.max_size());
	ASSERT_EQ(myempty_vec.empty(), empty_vec.empty());

	ASSERT_EQ(myvec.capacity(), vec.capacity());
}

int main()
{
	MyVector<int> intVector;
	MyVector<string> stringVector;

	intVector.push_back(3);
	intVector.push_back(4);

	stringVector.push_back("hi");
	stringVector.push_back("bye");

	for (int i = 0; i < intVector.size(); i++) {
		cout << intVector[i] << endl;
	}

	for (int i = 0; i < stringVector.size(); i++) {
		cout << stringVector[i] << endl;
	}

	return 0;
}

MyVector operator*(const MyMatrix& lhs ,const MyVector& rhs) {
    MyVector y = MyVector(lhs.rows_);
    if (lhs.columns_ == rhs.size()) {
        for(long long int i = 1; i <= lhs.rows_; i++) {
            for(long long int j = 1; j <= lhs.columns_; j++) {
                y[i-1] +=  rhs[j-1] *lhs.at(i,j);
            }
        }
    } else {
        cout << "Matrix-Vektor-Multiplikation nicht möglich  Dimensionen stimmen nicht überein!" << endl;
    }
    return y;
}

void MyVector::copy(const MyVector& rho)
{
	// Copy atomic attributes
	currentSize = rho.size();
	currentCapacity = rho.capacity();
	
	// Copy data payload
	payload = new int[currentCapacity];
	
	for (int i = 0; i < currentSize; i++)
	{
		payload[i] = rho.at(i);
	}
}

int main ()
{
   //Remove shared memory on construction and destruction
   struct shm_remove
   {
      shm_remove() { shared_memory_object::remove("MySharedMemory"); }
      ~shm_remove(){ shared_memory_object::remove("MySharedMemory"); }
   } remover;

   managed_shared_memory segment(
      create_only,
      "MySharedMemory", //segment name
      65536);           //segment size in bytes

   //Construct shared memory vector
   MyVector *myvector =
      segment.construct<MyVector>("MyVector")
      (IntAllocator(segment.get_segment_manager()));

   //Fill vector
   myvector->reserve(100);
   for(int i = 0; i < 100; ++i){
      myvector->push_back(i);
   }

   //Create the vectorstream. To create the internal shared memory
   //basic_string we need to pass the shared memory allocator as
   //a constructor argument
   MyVectorStream myvectorstream(CharAllocator(segment.get_segment_manager()));

   //Reserve the internal string
   myvectorstream.reserve(100*5);

   //Write all vector elements as text in the internal string
   //Data will be directly written in shared memory, because
   //internal string's allocator is a shared memory allocator
   for(std::size_t i = 0, max = myvector->size(); i < max; ++i){
      myvectorstream << (*myvector)[i] << std::endl;
   }

   //Auxiliary vector to compare original data
   MyVector *myvector2 =
      segment.construct<MyVector>("MyVector2")
      (IntAllocator(segment.get_segment_manager()));

   //Avoid reallocations
   myvector2->reserve(100);

   //Extract all values from the internal
   //string directly to a shared memory vector.
   std::istream_iterator<int> it(myvectorstream), itend;
   std::copy(it, itend, std::back_inserter(*myvector2));

   //Compare vectors
   assert(std::equal(myvector->begin(), myvector->end(), myvector2->begin()));

   //Create a copy of the internal string
   MyString stringcopy (myvectorstream.vector());

   //Now we create a new empty shared memory string...
   MyString *mystring =
      segment.construct<MyString>("MyString")
      (CharAllocator(segment.get_segment_manager()));

   //...and we swap vectorstream's internal string
   //with the new one: after this statement mystring
   //will be the owner of the formatted data.
   //No reallocations, no data copies
   myvectorstream.swap_vector(*mystring);

   //Let's compare both strings
   assert(stringcopy == *mystring);

   //Done, destroy and delete vectors and string from the segment
   segment.destroy_ptr(myvector2);
   segment.destroy_ptr(myvector);
   segment.destroy_ptr(mystring);
   return 0;
}

 /**
  * Gets the number of rows.
  * @return the number of rows.
  */
 int numRows() const {
     return table.size();
 }