设计一个float类型的数组类CFltArray，要求CFltArray可以进行如下操作：

Posted 2023-05-15

用C++实现
设计一个float类型的数组类CFltArray，要求CFltArray可以进行如下操作：
1. 可以重置数组的大小（Resize）
2. 可以通过下标返回数组元素，并对下标越界情况进行检查
3. 可以利用已知数组对象对整个数组赋值和初始化
4. 可以返回当前数组的大小（Size）
最后用数据验证你所设计的类

提示：
1. 利用已知数组对象对整个数组赋值，说明要求重载等号运算符
2. 利用已知数组对象对整个数组初始化，说明要求重载拷贝构造函数
3. 要求用指针存储数组对象中元素
http://topic.csdn.net/u/20080516/11/e0b07c93-51f0-412c-8bf1-fc0141169464.html
可参考下这个,不知道什么语言.改不成C++.
this.value = tmp;怎么改成c++的.改成this->value = tmp;
出现错误:
incompatiable types in assignment of 'float[((size-1)+1)]'to 'float[0]'
怎么把新数组赋给value数组呢?

完整程序
#include <cassert>
#include <iomanip>
#include <iostream>

#include <vector>
#include <algorithm>

using std::cin;
using std::setprecision;
using std::cout;
using std::endl;

class CFltArray

public:
CFltArray():m_iSize(0),m_pFloat(NULL);
CFltArray(int iSize);
CFltArray(float *fArray, int iSize);
CFltArray(const CFltArray &);
virtual ~CFltArray();

void ReSize(int iSize);
CFltArray &operator=(const CFltArray &);
float &operator[](int iIndex);
const float &operator[](int iIndex) const;
int GetSize() const ;
void Print()const;
private:
int m_iSize;
float *m_pFloat;
;

CFltArray::CFltArray(int iSize)

assert( iSize > 0);
m_iSize = iSize;

m_pFloat = new float[iSize];
assert( m_pFloat != NULL);
memset(m_pFloat, 0, sizeof(float)*iSize);


CFltArray::CFltArray(float *fArray, int iSize)

assert( fArray != NULL);
assert( iSize > 0);

m_iSize = iSize;

m_pFloat = new float[iSize];
assert( m_pFloat != NULL);
memset(m_pFloat, 0, sizeof(float)*iSize);

for(int i=0; i<iSize; i++)

m_pFloat[i] = fArray[i];



CFltArray::CFltArray(const CFltArray &fTemp)

m_iSize = fTemp.GetSize();
m_pFloat = new float[m_iSize];
assert( m_pFloat != NULL);

for(int i=0; i<m_iSize; i++)

m_pFloat[i] = fTemp[i];



CFltArray::~CFltArray()

delete []m_pFloat;
m_pFloat = NULL;


void CFltArray::ReSize(int iSize)

if(iSize == m_iSize) return;

if(iSize < m_iSize) //小于原来长度直接清空原来数据

delete []m_pFloat;
m_pFloat = new float[iSize];
assert( m_pFloat != NULL);
memset(m_pFloat, 0, sizeof(float)*iSize);

else //大于原来长度先保存原来数据，然后扩展空间，再把原来数据复制过来

int i=0;
float *pFTemp = new float[m_iSize];
assert( pFTemp != NULL);

for(i=0; i<m_iSize; i++)

pFTemp[i] = m_pFloat[i];


delete []m_pFloat;

m_pFloat = new float[iSize];
assert( m_pFloat != NULL);
memset(m_pFloat, 0, sizeof(float)*iSize);

for(i=0; i<m_iSize; i++)

m_pFloat[i] = pFTemp[i];


delete []pFTemp;


m_iSize = iSize;


CFltArray &CFltArray::operator=(const CFltArray &fTemp)

if(this != &fTemp)

delete []m_pFloat;
m_iSize = fTemp.GetSize();
m_pFloat = new float[m_iSize];
assert( m_pFloat != NULL);

for(int i=0; i<m_iSize; i++)

m_pFloat[i] = fTemp[i];



return *this;


float &CFltArray::operator[](int iIndex)

assert(iIndex>=0 && iIndex <m_iSize);
assert(m_pFloat != NULL);

return *(m_pFloat+iIndex);


const float &CFltArray::operator[](int iIndex) const

assert(iIndex>=0 && iIndex <m_iSize);
assert(m_pFloat != NULL);

return *(m_pFloat+iIndex);


int CFltArray::GetSize() const

return m_iSize;


void CFltArray::Print() const

assert(m_pFloat != NULL);

setprecision(3);
for(int i=0; i<m_iSize; i++)

cout <<i <<"------>" <<*(m_pFloat+i) <<endl;



int main()

float fTemp[]=22.32, 44.12, 31.24, 10.222, 5.26;

CFltArray fObj(fTemp, 5);

fObj.Print();

cout<<fObj[3] <<endl;
// cout <<fObj[11] <<endl;

fObj.ReSize(10);
fObj.Print();

cout <<"size:" <<fObj.GetSize() <<endl;

CFltArray f;
f = fObj;
f.Print();

return 0;



PS:二楼最经典：
#include <iostream>

#include <vector>
#include <algorithm>
using std::cout;
using std::endl;

using std::vector;

typedef vector<float> CFlt;

int main()

float fTemp[]=22.32, 44.12, 31.24, 10.222, 5.26;

CFlt vFlt(fTemp, fTemp+5);

std::ostream_iterator<float> out(cout, " ");
std::copy(vFlt.begin(), vFlt.end(), out);

vFlt.reserve(10);
std::copy(vFlt.begin(), vFlt.end(), out);

cout<<vFlt[1] <<endl;
cout<<vFlt.at(15)<<endl;
return 0;
参考技术A #include <iostream>
using namespace std;

class flt

public:
flt()size=0;
flt(int s,float a[]);
void Resize(int size);
float operator [](int index) const;
int Get_Size() const;
private:
float * arr;
int size;
;

flt::flt(int s,float a[])

arr=new float[s];
for(int i=0;i<s;i++)
arr[i]=a[i];
size=s;


void flt::Resize(int new_size)

float * tmp=arr;
int old_size=size;
arr=new float[new_size];
for(int i=0;i<old_size;i++)
arr[i]=tmp[i];
delete [] tmp;
size=new_size;


float flt::operator [](int index) const

if(index>=size)

cerr<<"error!"<<endl;
return -1;

return arr[index];


int flt::Get_Size() const

return size;


int main()

float a[3]=1.0,2.0,3.0;
flt f(3,a);
cout<<f[1]<<endl;
cout<<f.Get_Size()<<endl;
f.Resize(10);
cout<<f.Get_Size()<<endl;
return 0;
本回答被提问者采纳 参考技术B 直接用c++ STL(标准模板库）中的vector不久好了吗，满足你的所有要求。

java数组与集合

不论是基本数据类型，还是引用数据类型的数据，都可以使用集合的形式对它们进行操作。

数组：

数组在java中是一个特殊类，

java中的基本数据类型包括：byte，char，short，int，long,float,double,boolean 8中，其他的都是引用数据类型。

数组创建的时候必须指定一个长度

数组的复制，不能用 = 来直接，因为这样的两个数组指向同一个内存空间，修改一个会对另一个产生影响。可以使用java中的System.arraycopy()来复制，也可以自己用方法遍历。

集合：

集合是用来存储其他对象的对象，大致组成如图所示：

 

列表（list）：有序存放，允许重复，可以存放不同类型的对象        ArrayList，LinkedList

集合（set）：无序存放，不允许重复，可存放不同类型的对象，    HashSet，LinkedSet      

SortedSet：排好序列的Set                                                             TreeSet(有序)

映射（Map）：俗称键值对，如手机中的电话本                              HashMap

SortedMap：排好序列的Map                                                          TreeMap（有序）

 

 

Array在访问（查看）数据库时效率高，而在插入或者删除的时候效率低。

Linked在访问（查看）数据库时效率低，而在插入或者删除的时候效率高。

ArrayList在整体上效率高与LinkedList，因此大部分情况下都会选择ArrayList，除非很多时候需要进行插入和删除数据。

Vector是线程安全的，当遇到多线程时，也可以使用ArrayList，是用过Java提供的Collections类来转换成线程安全的类。

 

1.Linked的实现：

    底层使用双向链表来存储，

    每个节点都包含了对前一个和后一个元素的引用，

2.Hash的实现：

     使用数组来存储

     依赖hash算法来存储，我们知道每个对象都有它的hash值；

     HashSet底层是使用HashMap来存储的，在存储时按key-value来存储，只不过把值存在key中，而value则全部为null；

 

3.Tree的实现：