variable size of an arrary

I want to do the follows.
>
(1)initial an array, say myarray[]={1 2 3.1 4};
>
(2)insert zeros in myarray, like {1,0,2,0,3.1,0,4,0};
>
(3)let myarray[]={1,0,2,0,3.1,0,4,0}; (I have not idea how to figure
it out)
>
Therefore, the size of array myarray is variable.
>
Could anyone please help me to figure out the 3rd step?

ottawajn wrote:>
Arrays cannot chage their size. If you initialise the array with
like you showed here (you need commas between the values, not spaces),
you will not be able to insert anything there. You need to "reserve"
the space for zeros. It means you need to define the size manually:
>
double myarray[9] = { ...
>
And then, to insert a single value (zero) you could write a loop and
move all elements from the insertion position till the last one one
position towards the end. To insert several values you can call your
function in another loop.
>
However, it is better to use 'std::vector' since it can do all those
things for you (well, almost).
>
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

I want to do the follows.
>
(1)initial an array, say myarray[]={1 2 3.1 4};
>
(2)insert zeros in myarray, like {1,0,2,0,3.1,0,4,0};
>
(3)let myarray[]={1,0,2,0,3.1,0,4,0}; (I have not idea how to figure it
out)
>
Therefore, the size of array myarray is variable.
>
Could anyone please help me to figure out the 3rd step?

Thanks.
>
My concern is how to use vector. Could you explain it ?
>
Is the following right?
//***********************
vector <floatmyarray;

//how to define myarray={1,2,3.1,4}?

myarray.size(8);

//for...
{
myarry[i]=...
}

ottawajn wrote:>
As Victor says, you can't do this with arrays. In fact, you probably
shouldn't be using arrays anyway (see
<http://parashift.com/c++-faq-lite/containers.html#faq-34.1>).
>
Now, to answer your question, you could do something like this (not
tested):
>
#include <vector>
using namespace std;
>
template<typename T>
class Initializer
{
vector<Tv_;
public:
Initializer( const typename vector<T>::size_type capacity=0 )
{
v_.reserve( capacity );
}
>
Initializer& Add( const T& t )
{
v_.push_back(t);
return *this;
}
>
operator vector<T>() const
{
return v_;
}
};
>
vector<doubleInsertZeros( const vector<double>& v )
{
vector<doublev2;
v2.reserve( v.size() * 2 );
for( unsigned i=0; i < v.size(); ++i )
{
v2.push_back( v[ i ] );
v2.push_back( 0 );
}
return v2;
}
>
int main()
{
// Step 1
vector<doublev = Initializer<double>( 4 )
.Add(1.0)
.Add(2.0)
.Add(3.0)
.Add(4.0);
>
// Step 2
vector<doublez = InsertZeros( v );
>
// Step 3
v.swap( z );
>
return 0;
}
>
Of course there are various other ways to do the same thing and some
optimizations that you might apply, but that's the gist.
>
Cheers! --M

ottawajn wrote:>
As Victor says, you can't do this with arrays. In fact, you probably
shouldn't be using arrays anyway (see
<http://parashift.com/c++-faq-lite/containers.html#faq-34.1>).
>
Now, to answer your question, you could do something like this (not
tested):
>
#include <vector>
using namespace std;
>
template<typename T>
class Initializer
{
vector<Tv_;
public:
Initializer( const typename vector<T>::size_type capacity=0 )
{
v_.reserve( capacity );
}
>
Initializer& Add( const T& t )
{
v_.push_back(t);
return *this;
}
>
operator vector<T>() const
{
return v_;
}
};
>
vector<doubleInsertZeros( const vector<double>& v )
{
vector<doublev2;
v2.reserve( v.size() * 2 );
for( unsigned i=0; i < v.size(); ++i )
{
v2.push_back( v[ i ] );
v2.push_back( 0 );
}
return v2;
}
>
int main()
{
// Step 1
vector<doublev = Initializer<double>( 4 )
.Add(1.0)
.Add(2.0)
.Add(3.0)
.Add(4.0);
>
// Step 2
vector<doublez = InsertZeros( v );
>
// Step 3
v.swap( z );
>
return 0;
}
>
Of course there are various other ways to do the same thing and some
optimizations that you might apply, but that's the gist.
>
Cheers! --M

Thanks.