The Big Programming Thread - Page 300

class CoinButton : public QPushButton
{
Q_OBJECT
public:
    CoinButton(const QString& title, QWidget *parent = 0);
};

CoinButton::CoinButton(const QString& title, QWidget *parent) :
    QPushButton(title, parent)
{ /* Do anything else here */ }

class Node<T> {
    T value;
    Node<T> next;
    Node(T value, Node<T>, next) { this.value = value; this.next = next; }
}

class LinkedList<T> {
    Node<T> first;
    public LinkedList() { this.first = null; }
    public void push_back(T v) {
        Node<T> n = new Node(v, null);
        if (first == null) {
            first = n;
        } else {
            Node<T> cur = first;
            while (cur.next != null) { cur = cur.next; }
            cur.next = n;
        }
    }
}

template <typename T>
struct Node {
    T value;
    Node<T> *next;
    Node(T value, Node<T> *next = nullptr) {
        this->value = value; this->next = next;
    }
};

template <typename T>
class LinkedList<T> {
    Node<T> *first;
public:
    LinkedList() { this->first = nullptr; }
    void push_back(T v) {
        Node<T> *n = new Node(v, nullptr);
        if (first == nullptr) {
            first = n;
        } else {
            Node<T> *cur = first;
            while (cur->next != nullptr) { cur = cur->next; }
            cur->next = n;
        }
    }
};

LinkedList<int> *l = new LinkedList<int>();
l.push_back(0);
delete l;

template <typename T>
struct Node {
    // ...
    ~Node() { delete next; }
};

template <typename T>
class LinkedList<T> {
    // ...
    ~LinkedList() { delete first; }
};

template <typename T>
struct Node {
    // ...
    Node(T _value, Node<T> *_next = nullptr) : value(_value), next(_next) { }
};

template <typename T>
class LinkedList<T> {
    // ...
    LinkedList() : first(nullptr) { }
};

LinkedList<int> l1;
l1.push_back(0);
LinkedList<int> l2;
l2 = l1;

template <typename T>
struct Node {
    // ...
    Node(const Node &other) :
        value(other.value), next(new Node(*(other.next))) { }

    Node& operator=(const Node &other) {
        if (this != &other) {
            delete next;
            other = other.value
            next = new Node(*(other.next));
        }
        return *this;
    }
};

template <typename T>
struct LinkedList {
    // ...
    LinkedList(const LinkedList &other) : first(other.first) { }

    LinkedList& operator=(const LinkedList &other) {
        if (this != &other) {
            delete first;
            first = new Node(*(other.first));
        }
    }
}

• Using templates as generics,
  
• Explicit memory lifetime management with pointers,
  
• The destructor,
  
• Initializer lists,
  
• References, const, and copy semantics,
  
• Pointer aliasing and memory management,
  
• Operator overloading,
  
• Copy construction and copy assignment.
  

 
CREATE VIEW goodsAmount(name,number) AS
SELECT good_name, count(*) FROM  recepycomponent NATURAL JOIN goods
GROUP BY good_name;

SELECT name FROM goodsAmount
WHERE number >=3;