#include <iostream>
#include <algorithm>
#include <cassert>
using namespace std;

#define SIZE 256

class Stack {
private:
	unsigned int count;

public:
	vector<int> val;

	Stack(): val(SIZE), count(0) {}

	Stack(const Stack &s): val(SIZE) {
		std::copy(s.val.begin(), s.val.end(), val.begin());
		count = s.count;
	}

	Stack& operator=(const Stack &s) {
		if(this != &s) {
			std::copy(s.val.begin(), s.val.end(), val.begin());
			count = s.count;
		}

		return *this;
	}

	Stack& operator=(Stack &&s) {
		if(this != &s) {
			val = s.val;
			count = s.count;

			assert(val.size() == s.val.size());
		}

		return *this;
	}

	void push(int value) {
		if(count < SIZE) {		
			val[count] = value;
			count++;
			return; 
		}

		throw("stack is full");
	}	

	int pop() {
		if(count > 0) {
			int element = val[count-1];
			count--;
			return element;
		}

		throw("stack is empty");
	}

	bool empty() {
		return count == 0;
	}
};

int main() {
	Stack s;

	s.push(1);
	s.push(2);
	s.push(3);

	Stack a;
	a = s;

	while(!a.empty()) {
		cout << a.pop() << endl;
	}

	Stack b;
	b = std::move(s);

	while(!b.empty()) {
		cout << b.pop() << endl;
	}

	Stack c(s);
	while(!c.empty()) {
		cout << c.pop() << endl;
	}

	return 0;	
}

val = std::move(s.val);

lauten. s ist keine rvalue-Referenz (es hat einen Namen).

Deine Implementierung an sich ist fragwürdig;
- define für eine Konstante
- wozu überhaupt diese Konstante, std::vector verwaltet speicher dynamisch

#include <iostream>
#include <algorithm>
#include <cassert>
#include <array>
using namespace std;

#define SIZE 256

class Stack {
private:
	unsigned int count;

public:
	array<int, SIZE> data;

	Stack(): count(0) {}

	Stack(const Stack &s) {
		std::copy(s.data.begin(), s.data.end(), data.begin());
		count = s.count;
	}

	Stack(const Stack &&s) {
		data = std::move(s.data);
		count = std::move(s.count);
	}

	Stack& operator=(const Stack &s) {
		if(this != &s) {
			std::copy(s.data.begin(), s.data.end(), data.begin());
			count = s.count;
		}

		return *this;
	}

	Stack& operator=(Stack &&s) {
		if(this != &s) {
			data = std::move(s.data);
			count = std::move(s.count);
		}

		return *this;
	}

	void push(int value) {
		if(count < SIZE) {		
			data[count] = value;
			count++;
			return; 
		}

		throw("stack is full");
	}	

	int pop() {
		if(count > 0) {
			int element = data[count-1];
			count--;
			return element;
		}

		throw("stack is empty");
	}

	bool empty() {
		return count == 0;
	}
};

int main() {
	Stack s;

	s.push(1);
	s.push(2);
	s.push(3);

	Stack a;
	a = s;

	while(!a.empty()) {
		cout << a.pop() << endl;
	}

	Stack b;
	b = std::move(s);

	while(!b.empty()) {
		cout << b.pop() << endl;
	}

	Stack c(s);
	while(!c.empty()) {
		cout << c.pop() << endl;
	}

	return 0;	
}

so besser?

Was erhoffst du dir davon, ein int zu verschieben?
Was liefert empty() des Stacks, von dem du die Daten verschoben hast?

niko1 schrieb:

das std::move in der main ist ok?

std::move ist immer ok! Aber was passiert später bei

Stack c(s);

wenn die daten verschoben werden, dann ist der stack natuerlich empty.
muss den counter noch ruecksetzen...willst du auf das raus?

Ja. Trotzdem ist dein Stack danach im Eimer, du kannst ihn nicht mehr benutzen.

d.h. der move assignment operator macht hier keinen sinn?

Was ist hier?
Deine main-Funktion ist sinnlos, aber für eine Funktion die einen Stack füllt und dann zurück liefert könnte es sinnvoll sein.

kann jemand ein beispiel posten wo der move assignment operator / move constructor sinn macht?

Davon gibt es bestimmt genug, dass du welche im Netz findest. Das #1-Beispiel ist sicherlich ein Smart-Pointer wie unique_ptr .

Siehe hier, die Zeilen 119-147.

#include <iostream> 
#include <algorithm> 
#include <cassert> 
#include <array> 
using namespace std; 

#define SIZE 256 

class Stack { 
private: 
    unsigned int count; 

public: 
    array<int, SIZE> data; 

    Stack(): count(0) {} 

    Stack(const Stack &s) { 
    	cout << "Stack(const Stack &s) called" << endl;
        std::copy(s.data.begin(), s.data.end(), data.begin()); 
        count = s.count; 
    } 

    Stack(Stack &&s) {
    	cout << "Stack(Stack &&s) called" << endl;
    	data = std::move(s.data); 
        count = std::move(s.count); 
        s.count = 0;
    } 

    Stack& operator=(const Stack &s) { 
    	cout << "Stack& operator=(const Stack &s) called" << endl;
        if(this != &s) { 
            std::copy(s.data.begin(), s.data.end(), data.begin()); 
            count = s.count; 
        } 

        return *this; 
    } 

    Stack& operator=(Stack &&s) {
    	cout << "Stack& operator=(Stack &&s) called" << endl;
        if(this != &s) { 
   			data = std::move(s.data); 
            count = std::move(s.count); 
            s.count = 0;
        } 

        return *this; 
    } 

    void push(int value) { 
        if(count < SIZE) {      
            data[count] = value; 
            count++; 
            return; 
        } 

        throw("stack is full"); 
    }   

    int pop() { 
        if(count > 0) { 
            int element = data[count-1]; 
            count--; 
            return element; 
        } 

        throw("stack is empty"); 
    } 

    bool empty() { 
        return count == 0; 
    } 
}; 

int main() { 
    Stack s; 

    s.push(1); 
    s.push(2); 
    s.push(3); 

    Stack a; 
    a = s;
  	cout << "empty: " << s.empty() << endl;

    while(!a.empty()) { 
        cout << a.pop() << endl; 
    } 

    Stack b; 
    b = std::move(s); 
  	cout << "empty: " << s.empty() << endl;

    while(!b.empty()) { 
        cout << b.pop() << endl; 
    }

  	Stack x;
  	Stack y(std::move(x));

    return 0;   
}

Stack& operator = (Stack other)

Stack s(s);

ist folgendes ein potentielles problem? der compiler meldet auch keinen fehler, soll das so sein?

Stack s(s);

Das Problem existiert, ist aber nur theoretischer Natur.

int main()
{
  std::string s	= s;
  std::cout << s; // Programm stürzt ab.
}

Kein normaler Mensch schreibt sowas.

Selbstzuweisung über operator= kann hingegen viel einfacher vorkommen wegen Aliasing. Beim Kopierkonstruktor ist das dagegen ein non-issue.