自定义的Troop 泛型类（ c++, java和c#）的实现代码

Troop<T>是一个泛型列表操作类，适用于非高性能和非大数据量的要求。包括了：取值get，赋值set，追加append，插入insert，清除remove，进队enqueue，出队dequeue，交换swap，滚动roll，进栈push，出栈pop等日常操作。

//for more information, please access http://www.one-lab.net

using System;
using System.Collections.Generic;
using System.Text;

namespace onelab
{
  public interface ISortable
  {
    void sort(bool decending);
  }

  public interface IStringable
  {
    int fromString(String input);
    String toString();
  }

  public class Troop<T> : ICloneable
  {
    public override int GetHashCode()
    {
      return base.GetHashCode();
    }
    public override bool Equals(object obj) { return this == (Troop<T>)obj; }
    public object Clone()
    {
      Troop<T> oValue = new Troop<T>();
      oValue.cloneFrom(this);
      return oValue;
    }
    protected bool equalsTo(Troop<T> aValue)
    {
      int len = aValue.length();
      if (len == this.length())
      {
        for (int n = 0; n < len; n++)
        {
          if (!aValue.data[n].Equals(data[n]))
            return false;
        }
        return true;
      }
      return false;
    }
    protected void cloneFrom(Troop<T> aValue)
    {
      data.Clear();
      data.AddRange(aValue.data);
    }
    public static bool operator ==(Troop<T> a0, Troop<T> a1) { object o1 = (object)a0; object o2 = (object)a1; if (o1 == null && o2 == null) return true; return (o1 == null || o2 == null) ? false : a0.equalsTo(a1); }
    public static bool operator !=(Troop<T> a0, Troop<T> a1) { object o1 = (object)a0; object o2 = (object)a1; if (o1 == null && o2 == null) return false; return (o1 == null || o2 == null) ? true : !a0.equalsTo(a1); }
    private bool mHasError = false;
    public bool hasError() { return mHasError; }
    public List<T> data = new List<T>();
    public T get(int index)
    {
      mHasError = false;
      if (index >= 0 && index < data.Count)
        return data[index];
      mHasError = true;
      return default(T);
    }
    public bool set(int index, T value)
    {
      if (index >= 0 && index < data.Count)
      {
        data[index] = value;
        return true;
      }
      return false;
    }
    public void append(T value)
    {
      data.Add(value);
    }
    public bool insert(int index, T value)
    {
      if (index >= 0 && index < data.Count)
      {
        data.Insert(index, value);
        return true;
      }
      return false;
    }
    public void appendRange(ref List<T> range)
    {
      data.AddRange(range);
    }
    public bool insertRange(int index, ref List<T> range)
    {
      if (index >= 0 && index < data.Count)
      {
        data.InsertRange(index, range);
        return true;
      }
      return false;
    }
    public void clear()
    {
      data.Clear();
    }
    public bool remove(int index)
    {
      if (index >= 0 && index < data.Count)
      {
        data.RemoveAt(index);
        return true;
      }
      return false;
    }
    public bool removeRange(int index, int count)
    {
      if (count > 0 && index >= 0 && ((index + count) <= data.Count))
      {
        data.RemoveRange(index, count);
        return true;
      }
      return false;
    }
    public int length()
    {
      return data.Count;
    }
    public void enqueue(T value)
    {
      data.Insert(0, value);
    }
    public T dequeue()
    {
      mHasError = false;
      int length = data.Count;
      if (length > 0)
      {
        T b = data[length - 1];
        data.RemoveAt(length - 1);
        return b;
      }
      mHasError = true;
      return default(T);
    }
    public void push(T value)
    {
      data.Add(value);
    }
    public T pop()
    {
      return dequeue();
    }
    public Troop<T> getRange(int index, int count)
    {
      Troop<T> output = new Troop<T>();
      mHasError = true;
      if (count > 0 && index >= 0 && ((index + count) <= data.Count))
      {
        output.data = data.GetRange(index, count);
        mHasError = false;
      }
      return output;
    }
    public void reverse()
    {
      data.Reverse();
    }
    public bool swap(int index0, int index1)
    {
      int length = data.Count;
      if (index0 >= 0 && index0 < length && index1 >= 0 && index1 < length)
      {
        T v = data[index0];
        data[index0] = data[index1];
        data[index1] = v;
        return true;
      }
      return false;

    }
    public T take(int index)
    {
      mHasError = false;
      if (index >= 0 && index < data.Count)
      {
        T v = data[index];
        data.RemoveAt(index);
        return v;
      }
      mHasError = true;
      return default(T);
    }
    public void rollForward(int offset)
    {
      if (offset >= data.Count) return;
      List<T> left = data.GetRange(offset - 1, data.Count - offset + 1);
      List<T> right = data.GetRange(0, offset - 1);
      data.Clear();
      data.AddRange(left);
      data.AddRange(right);
    }
    public void rollBackward(int offset)
    {
      if (offset >= data.Count) return;
      List<T> left = data.GetRange(offset, data.Count - offset);
      List<T> right = data.GetRange(0, offset);
      data.Clear();
      data.AddRange(left);
      data.AddRange(right);
    }
  }
}

//for more information, please access http://www.one-lab.net

#ifndef VALUES_H
#define VALUES_H

#include <QList>
#include <QDebug>

namespace onelab
{
  class ISortable
  {
  public:
    virtual void sort(bool decending) = 0;
  };

  template <typename T>
  class Troop
  {
  private:
    bool mHasError;
    static bool equals(const Troop<T> &from, const Troop<T> &to);

  public:
    QList<T> data;
    Troop();
    T get(int index);
    bool set(int index, T value);
    void append(T value);
    bool insert(int index, T value);
    void appendRange(const QList<T>& range);
    bool insertRange(int index, const QList<T>& range);
    void clear();
    bool remove(int index);
    bool removeRange(int index, int count);
    int length() const;
    void enqueue(T value);
    T dequeue();
    void push(T value);
    T pop();
    bool getRange(int index, int count, Troop<T>& output);
    void reverse();
    bool swap(int index0, int index1);
    T take(int index);
    void rollForward(int offset);
    void rollBackward(int offset);
    bool operator==(const Troop& input) const;
    bool operator!=(const Troop& input) const;
    bool hasError() const;
    virtual QString toString();
    virtual int fromString(const QString& input);
  };
}

#endif // VALUES_H

//for more information, please access http://www.one-lab.net

#include "values.h"
#include <QStringList>
#include <QDateTime>

namespace onelab
{
template <typename T>
bool Troop<T>::equals(const Troop<T> &from, const Troop<T> &to)
{
  int len = from.length();
  if (len == to.length())
  {
    for (int n = 0; n < len; n++)
    {
      if (from.data[n] != to.data[n])
        return false;
    }
    return true;
  }
  return false;
}

template <typename T>
Troop<T>::Troop()
{
  mHasError = false;
}

template <typename T>
T Troop<T>::get(int index)
{
  mHasError = false;
  if (index >= 0 && index < data.length())
    return data[index];
  mHasError = true;
  return (T)0;
}

template <typename T>
bool Troop<T>::set(int index, T value)
{
  if (index >= 0 && index < data.length())
  {
    data[index] = value;
    return true;
  }
  return false;
}

template <typename T>
void Troop<T>::append(T value)
{
  data.append(value);
}

template <typename T>
bool Troop<T>::insert(int index, T value)
{
  if (index >= 0 && index < data.length())
  {
    data.insert(index, value);
    return true;
  }
  return false;
}

template <typename T>
void Troop<T>::appendRange(const QList<T> &range)
{
  data.append(range);
}

template <typename T>
bool Troop<T>::insertRange(int index, const QList<T> &range)
{
  int length = data.length();
  if (index >= 0 && index < length)
  {
    QList<T> left = data.mid(0, index);
    QList<T> right = data.mid(index, -1);
    left.append(range);
    data.clear();
    data.append(left);
    data.append(right);
    return true;
  }
  return false;
}

template <typename T>
void Troop<T>::clear()
{
  data.clear();
}

template <typename T>
bool Troop<T>::remove(int index)
{
  if (index >= 0 && index < data.length())
  {
    data.removeAt(index);
    return true;
  }
  return false;
}

template <typename T>
bool Troop<T>::removeRange(int index, int count)
{
  if (count > 0 && index >= 0 && ((index + count) <= data.length()))
  {
    for (int n = 0; n < count; n++)
      data.removeAt(index);
    return true;
  }
  return false;
}

template <typename T>
int Troop<T>::length() const
{
  return data.length();
}

template <typename T>
void Troop<T>::enqueue(T value)
{
  data.insert(0, value);
}

template <typename T>
T Troop<T>::dequeue()
{
  mHasError = false;
  int length = data.length();
  if (length > 0)
  {
    T b = data[length - 1];
    data.removeAt(length - 1);
    return b;
  }
  mHasError = true;
  return (T)0;
}

template <typename T>
void Troop<T>::push(T value)
{
  data.append(value);
}

template <typename T>
T Troop<T>::pop()
{
  return dequeue();
}

template <typename T>
bool Troop<T>::getRange(int index, int count, Troop<T>& output)
{
  mHasError = true;
  if (count > 0 && index >= 0 && ((index + count) <= data.length()))
  {
    output.data = data.mid(index, count);
    mHasError = false;
  }
  return mHasError;
}

template <typename T>
void Troop<T>::reverse()
{
  int length = data.length();
  QList<T> newData;
  for (int n = length - 1; n >= 0; n--)
    newData.append(data[n]);

  data.clear();
  data = newData;
}

template <typename T>
bool Troop<T>::swap(int index0, int index1)
{
  int length = data.length();
  if (index0 >= 0 && index0 < length && index1 >= 0 && index1 < length)
  {
    T v = data[index0];
    data[index0] = data[index1];
    data[index1] = v;
    return true;
  }
  return false;
}

template <typename T>
T Troop<T>::take(int index)
{
  mHasError = false;
  if (index >= 0 && index < data.length())
  {
    T v = data[index];
    data.removeAt(index);
    return v;
  }
  mHasError = true;
  return (T)0;
}

template <typename T>
void Troop<T>::rollForward(int offset)
{
  if (offset >= data.length()) return;
  QList<T> left = data.mid(offset - 1, -1);
  QList<T> right = data.mid(0, offset - 1);
  data.clear();
  data.append(left);
  data.append(right);
}

template <typename T>
void Troop<T>::rollBackward(int offset)
{
  if (offset >= data.length()) return;
  QList<T> left = data.mid(offset, -1);
  QList<T> right = data.mid(0, offset);
  data.clear();
  data.append(left);
  data.append(right);
}

template <typename T>
bool Troop<T>::operator!=(const Troop& input) const
{
  return !equals(input, *this);
}

template<typename T>
bool Troop<T>::hasError() const
{
  return mHasError;
}

template<typename T>
QString Troop<T>::toString()
{
  return QString();
}

template<typename T>
int Troop<T>::fromString(const QString&)
{
  return 0;
}

template <typename T>
bool Troop<T>::operator==(const Troop& input) const
{
  return equals(input, *this);
}

}
//for more information, please access http://www.one-lab.net

package net.onelab;

import java.util.ArrayList;

public class Troop<T> implements Cloneable {
 public Object clone() {
 Troop<T> obj = new Troop<T>();
 obj.data.addAll(data);
 return obj;
 }

 private boolean mHasError = false;
 public boolean hasError() { return mHasError; }
 public ArrayList<T> data = new ArrayList<T>();
 public T get(int index) {
 mHasError = false;
 if (index >= 0 && index < data.size())
  return data.get(index);
 mHasError = true;
 return null;

 }
 public boolean set(int index, T value) {
 if (index >= 0 && index < data.size())
 {
  data.set(index, value);
  return true;
 }
 return false;
 }
  public void append(T value) {
    data.add(value);
  }
  public boolean insert(int index, T value) {
    if (index >= 0 && index < data.size())
    {
      data.add(index, value);
      return true;
    }
    return false;
  }
  public void appendRange(ArrayList<T> range) {
    data.addAll(range);
  }
  public boolean insertRange(int index, ArrayList<T> range) {
    if (index >= 0 && index < data.size())
    {
      data.addAll(index, range);
      return true;
    }
    return false;
  }
  public void clear() {
    data.clear();
  }
  public boolean remove(int index) {
    if (index >= 0 && index < data.size())
    {
      data.remove(index);
      return true;
    }
    return false;
  }
  public boolean removeRange(int index, int count) {
    if (count > 0 && index >= 0 && ((index + count) <= data.size()))
    {
      for (int n = 0; n < count; n++)
       data.remove(index);

      return true;
    }
    return false;
  }
  public int length() {
    return data.size();
  }
  public void enqueue(T value) {
    data.add(0, value);
  }
  public T dequeue() {
    mHasError = false;
    int length = data.size();
    if (length > 0)
    {
      T b = data.get(length - 1);
      data.remove(length - 1);
      return b;
    }
    mHasError = true;
    return null;
  }
  public void push(T value) {
    data.add(value);
  }
  public T pop() {
    return dequeue();
  }
  public Troop<T> getRange(int index, int count) {
    mHasError = true;
    Troop<T> output = new Troop<T>();
    if (count > 0 && index >= 0 && ((index + count) <= data.size()))
    {
     output.data.addAll(data.subList(index, index + count));
      mHasError = false;
    }
    return output;
  }
  public void reverse() {
   int length = data.size();
   ArrayList<T> newData = new ArrayList<T>();
   for (int n = length - 1; n >= 0; n--)
   newData.add(data.get(n));

   data.clear();
   data = newData;
  }

  boolean swap(int index0, int index1) {
    int length = data.size();
    if (index0 >= 0 && index0 < length && index1 >= 0 && index1 < length)
    {
      T v = data.get(index0);
      data.set(index0, data.get(index1));
      data.set(index1, v);
      return true;
    }
    return false;
  }
  T take(int index)
  {
    mHasError = false;
    if (index >= 0 && index < data.size())
    {
      T v = data.get(index);
      data.remove(index);
      return v;
    }
    mHasError = true;
    return null;
  }
  void rollForward(int offset)
  {
    if (offset >= data.size()) return;
    ArrayList<T> left = new ArrayList<T>();
    left.addAll(data.subList(offset - 1, data.size()));
    ArrayList<T> right = new ArrayList<T>();
    right.addAll(data.subList(0, offset - 1));
    data.clear();
    data.addAll(left);
    data.addAll(right);
  }
  void rollBackward(int offset)
  {
    if (offset >= data.size()) return;
    ArrayList<T> left = new ArrayList<T>();
    left.addAll(data.subList(offset, data.size()));
    ArrayList<T> right = new ArrayList<T>();
    right.addAll(data.subList(0, offset));
    data.clear();
    data.addAll(left);
    data.addAll(right);
  }
}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

原文链接：https://my.oschina.net/u/1377242/blog/908322