array.h

关于遗传算法的c++程序,本文采用了实数编码

#ifndef SimpleFArrayH
#define SimpleFArrayH

typedef float Real;

class SimpleFArray {
public:
    SimpleFArray(int n);                               // Create array of n elements
    SimpleFArray();                                    // Create array of 0 elements
    SimpleFArray(const SimpleFArray&);                 // Copy array
    ~SimpleFArray();                                   // Destroy array
    Real& operator[](int i);                          // Subscripting
    const Real& operator[](int i) const;              // Subscripting
    int numElts() const;                               // Number of elements
    SimpleFArray& operator=(const SimpleFArray&);      // Array assignment
    SimpleFArray& operator=(const&);                   // Scalar assignment 
    void setSize(int n);                               // Change size
private:
    int num_elts;                                      // Number of elements
    Real* ptr_to_data;                                // Pointer to built-in array of elements
    void copy(const SimpleFArray& a);                  // Copy in elements of a

};



SimpleFArray::SimpleFArray(int n) {
    num_elts = n;
    ptr_to_data = new Real[n];
}

SimpleFArray::SimpleFArray() {
    num_elts = 0;
    ptr_to_data = 0;
}

SimpleFArray::SimpleFArray(const SimpleFArray& a) {
    num_elts = a.num_elts;
    ptr_to_data = new Real[num_elts];
    copy(a); // Copy a's elements
}

void SimpleFArray::copy(const SimpleFArray& a) {
    // Copy a's elements into the elements of *this
    Real* p = ptr_to_data + num_elts;
    Real* q = a.ptr_to_data + num_elts;
    while (p > ptr_to_data) *--p = *--q;
}

SimpleFArray::~SimpleFArray() {
    delete [] ptr_to_data;
}

Real& SimpleFArray::operator[](int i) {
    return ptr_to_data[i];
}

const Real& SimpleFArray::operator[](int i) const {
    return ptr_to_data[i];
}

int SimpleFArray::numElts() const {
    return num_elts;
}

SimpleFArray& SimpleFArray::operator=(const SimpleFArray& rhs) {
    if (ptr_to_data != rhs.ptr_to_data ) {
        setSize( rhs.num_elts );
        copy(rhs);
    }
    return *this;
}

void SimpleFArray::setSize(int n) {
    if (n != num_elts) {
        delete [] ptr_to_data;    // Delete old elements,
        num_elts = n;             // set new count,
        ptr_to_data = new Real[n];   // and allocate new elements

    }
}

SimpleFArray& SimpleFArray::operator=(const int& rhs) {
    Real* p = ptr_to_data + num_elts;
    while (p > ptr_to_data) *--p = rhs;
    return *this;
}

#endif
#ifndef SimpleIArrayH
#define SimpleIArrayH

class SimpleIArray {
public:
    SimpleIArray(int n);                               // Create array of n elements
    SimpleIArray();                                    // Create array of 0 elements
    SimpleIArray(const SimpleIArray&);                 // Copy array
    ~SimpleIArray();                                   // Destroy array
    int& operator[](int i);                            // Subscripting
    const int& operator[](int i) const;                // Subscripting
    int numElts() const;                               // Number of elements
    SimpleIArray& operator=(const SimpleIArray&);      // Array assignment
    SimpleIArray& operator=(const&);                   // Scalar assignment 
    inline void setSize(int n);                        // Change size
private:
    int num_elts;                                      // Number of elements
    int* ptr_to_data;                                  // Pointer to built-in array of elements
    void copy(const SimpleIArray& a);                  // Copy in elements of a

};


SimpleIArray::SimpleIArray(int n) {
    num_elts = n;
    ptr_to_data = new int[n];
}

SimpleIArray::SimpleIArray() {
    num_elts = 0;
    ptr_to_data = 0;
}

SimpleIArray::SimpleIArray(const SimpleIArray& a) {
    num_elts = a.num_elts;
    ptr_to_data = new int[num_elts];
    copy(a); // Copy a's elements
}

void SimpleIArray::copy(const SimpleIArray& a) {
    // Copy a's elements into the elements of *this
    int* p = ptr_to_data + num_elts;
    int* q = a.ptr_to_data + num_elts;
    while (p > ptr_to_data) *--p = *--q;
}

SimpleIArray::~SimpleIArray() {
    delete [] ptr_to_data;
}

int& SimpleIArray::operator[](int i) {
    return ptr_to_data[i];
}

const int& SimpleIArray::operator[](int i) const {
    return ptr_to_data[i];
}

int SimpleIArray::numElts() const {
    return num_elts;
}

SimpleIArray& SimpleIArray::operator=(const SimpleIArray& rhs) {
    if (ptr_to_data != rhs.ptr_to_data ) {
        setSize( rhs.num_elts );
        copy(rhs);
    }
    return *this;
}

void SimpleIArray::setSize(int n) {
    if (n != num_elts) {
        delete [] ptr_to_data;    // Delete old elements,
        num_elts = n;             // set new count,
        ptr_to_data = new int[n];   // and allocate new elements

    }
}

SimpleIArray& SimpleIArray::operator=(const int& rhs) {
    int* p = ptr_to_data + num_elts;
    while (p > ptr_to_data) *--p = rhs;
    return *this;
}

#endif
#ifndef SimpleArrayH
#define SimpleArrayH

template<class T> class SimpleArray;

template<class T>
class SimpleArray {
public:
    inline SimpleArray(int n);                                 // Create array of n elements
    inline SimpleArray();                                      // Create array of 0 elements
    inline SimpleArray(const SimpleArray<T>&);                 // Copy array
    inline ~SimpleArray();                                     // Destroy array
    inline T& operator[](int i);                               // Subscripting
    inline const T& operator[](int i) const;                   // Subscripting
    inline int numElts() const;                                // Number of elements
    SimpleArray<T>& operator=(const SimpleArray<T>&);          // Array assignment
    SimpleArray<T>& operator=(const T&);                       // Scalar assignment 
    inline void setSize(int n);                                // Change size
private:
    int num_elts;                                              // Number of elements
    T* ptr_to_data;                                            // Pointer to built-in array of elements
    void copy(const SimpleArray<T>& a);                        // Copy in elements of a

};



template<class T>
inline SimpleArray<T>::SimpleArray(int n) {
    num_elts = n;
    ptr_to_data = new T[n];
}

template<class T>
inline SimpleArray<T>::SimpleArray() {
    num_elts = 0;
    ptr_to_data = 0;
}

template<class T>
inline SimpleArray<T>::SimpleArray(const SimpleArray<T>& a) {
    num_elts = a.num_elts;
    ptr_to_data = new T[num_elts];
    copy(a); // Copy a's elements
}

template<class T>
void SimpleArray<T>::copy(const SimpleArray<T>& a) {
    // Copy a's elements into the elements of *this
    T* p = ptr_to_data + num_elts;
    T* q = a.ptr_to_data + num_elts;
    while (p > ptr_to_data) *--p = *--q;
}

template<class T>
inline SimpleArray<T>::~SimpleArray() {
    delete [] ptr_to_data;
}

template<class T>
inline T& SimpleArray<T>::operator[](int i) {
    return ptr_to_data[i];
}

template<class T>
inline const T& SimpleArray<T>::operator[](int i) const {
    return ptr_to_data[i];
}

template<class T>
inline int SimpleArray<T>::numElts() const {
    return num_elts;
}

template<class T>
SimpleArray<T>& SimpleArray<T>::operator=(const SimpleArray<T>& rhs) {
    if ( ptr_to_data != rhs.ptr_to_data ) {
        setSize( rhs.num_elts );
        copy(rhs);
    }
    return *this;
}

template<class T>
inline void SimpleArray<T>::setSize(int n) {
    if (n != num_elts) {

        delete [] ptr_to_data;    // Delete old elements,
        num_elts = n;             // set new count,
        ptr_to_data = new T[n];   // and allocate new elements

    }
}

template<class T>
SimpleArray<T>& SimpleArray<T>::operator=(const T& rhs) {
    T* p = ptr_to_data + num_elts;
    while (p > ptr_to_data) *--p = rhs;
    return *this;
}

#endif