自定义的Troop<T>泛型类（ 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
.Equals(data
))
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
 != to.data
)
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
);
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);
}
}

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

您可能感兴趣的文章:

• 浅谈java中定义泛型类和定义泛型方法的写法
• Java泛型类型通配符和C#对比分析
• java泛型类的定义与使用详解