Форум программистов, компьютерный форум CyberForum.ru

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
#1

Непонятный вывод: постфиксные и префиксные инкремент/декремент - C++

27.08.2013, 12:29. Просмотров 439. Ответов 2
Метки нет (Все метки)

Под спойлером весь который можно просто скопипастить и запустить в онлайн компиляторе http://www.compileonline.com/compile_cpp11_online.php
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
#include <iostream>
 
using namespace std;
 
//-------------------------------------------------------
// class Int
class Int {
public:
    // constructors
    Int(int n = 0) : member(n) { }
    Int(const Int& i) : member(i.member) { }
    Int& operator=(const Int& i);
    // access
    int data() const { return member; }
    // modyfication
    void set_member(int n) { member = n; }
    // operators
    const Int& operator+() {return *this; } // unary+ operator
    const Int operator-() {return Int(-this->member); }  //unary- operator
    const Int& operator++() {++member; return *this; } // prefix ++ increment operator
    const Int operator++(int) {Int Old_value(*this); ++member; return Old_value; } // postfix ++ increment operator
    const Int& operator--() {--member; return *this; }  // prefix ++ increment operator
    const Int operator--(int) {Int Old_value(*this); --member; return Old_value; } // postfix ++ increment operator
private:
    int member;
};
//-------------------
// members
// assignment operator
Int& Int::operator=(const Int& i) { 
    if(this==&i) return *this;
    member = i.member;
    return *this;
}
//-------------------
// not members
// binary operator+
const Int operator+(const Int& left, const Int& right) {
    return Int(left.data()+right.data());
}
//-------------------
// binary operator-
const Int operator-(const Int& left, const Int& right) {
    return Int(left.data()-right.data());
}
//-------------------
// binary operator*
const Int operator*(const Int& left, const Int& right) {
    return Int(left.data()*right.data());
}
//-------------------
// binary operator/
const Int operator/(const Int& left, const Int& right) {
    return Int(left.data()/right.data());
}
//-------------------
// binary operator%
const Int operator%(const Int& left, const Int& right) {
    return Int(left.data()%right.data());
}
//-------------------
// operator>>
istream& operator>>(istream& is, Int& i) { 
        int n;
        is >> n;
        if (is) i.set_member(n);
        return is;
}
//-------------------
// operator<<
ostream& operator<<(ostream& os, const Int& i) {
        os << i.data();
        return os;
}
 
//-------------------------------------------------------
// class template<class T> Number
template<class T>
class Number {
public:
    // constructors
    Number(T n = 0) : member(n) { }
    Number(const Number& i) : member(i.member) { }
    Number& operator=(const Number& n);
    // access
    T data() const { return member; }
    // modyfication
    void set_member(T n) { member = n; }
    // operators
    const Number& operator+() {return *this; } // unary+ operator
    const Number operator-() {return Number(-member); }  //unary- operator
    const Number& operator++() {member++; return *this; } // prefix ++ increment operator
    const Number operator++(int) {Number Old_value(*this); member++; return Old_value; } // postfix ++ increment operator
    const Number& operator--() {member--; return *this; }  // prefix ++ increment operator
    const Number operator--(int) {Number Old_value(*this); member--; return Old_value; } // postfix ++ increment operator
private:
    T member;
};
//-------------------
// members
// assignment operator
template<class T>
Number<T>& Number<T>::operator=(const Number<T>& n) { 
    if(this==&n) return *this;
    member = n.member;
    return *this;
}
//-------------------
// not members
// binary operator+
template<class T>
const Number<T> operator+(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()+right.data());
}
//-------------------
// binary operator-
template<class T>
const Number<T> operator-(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()-right.data());
}
//-------------------
// binary operator*
template<class T>
const Number<T> operator*(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()*right.data());
}
//-------------------
// binary operator/
template<class T>
const Number<T> operator/(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()/right.data());
}
//-------------------
// binary operator%
template<class T>
const Number<T> operator%(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()%right.data());
}
//-------------------
// operator>>
template<class T>
istream& operator>>(istream& is, Number<T>& i) { 
        T n;
        is >> n;
        if (is) i.set_member(n);
        return is;
}
//-------------------
// operator<<
template<class T>
ostream& operator<<(ostream& os, const Number<T>& i) {
        os << i.data();
        return os;
}
 
 
int main()
{
    Int i(10);
    cout << -i << "; and value is " << i << endl;
    cout << --i << "; and value is " << i << endl;
    cout << +i << "; and value is " << i << endl;
    cout << ++i << "; and value is " << i << endl;
    cout << "postfix operators" << endl;
    cout << i++ << "; and value is " << i << endl;
    cout << i-- << "; and value is " << i << endl;
 
    cout << endl << "-----------------" << endl;
 
    Number<int> n1(100);
    Number<int> n2(5);
    cout << n1 << " % " << n2 << " == " <<n1%n2 << endl;
    cout << n1 << " / " << n2 << " == " <<n1/n2 << endl;
    cout << n1 << " * " << n2 << " == " <<n1*n2 << endl;
    cout << n1 << " - " << n2 << " == " <<n1-n2 << endl;
    cout << n1 << " + " << n2 << " == " <<n1+n2 << endl;
    
    cout << "n1 == 100; correct work:" << endl;
    cout << n1;
    cout << " prefix-- == " << --n1 << endl;
    cout << n1;
    cout << " postfix++ == " << n1++ << "; and n1 value == " << n1 << endl;
    cout << "----------------" << endl;
    
    cout << "n1 == 100; incorrect work:" << endl;
    cout << n1 << " prefix-- == " << --n1 << endl;
    cout << n1 << " postfix++ == " << n1++ << "; and n1 value == " << n1 << endl;
    
 
   return 0;
}


Есть два класса.
Первый:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
//-------------------------------------------------------
// class Int
class Int {
public:
    // constructors
    Int(int n = 0) : member(n) { }
    Int(const Int& i) : member(i.member) { }
    Int& operator=(const Int& i);
    // access
    int data() const { return member; }
    // modyfication
    void set_member(int n) { member = n; }
    // operators
    const Int& operator+() {return *this; } // unary+ operator
    const Int operator-() {return Int(-this->member); }  //unary- operator
    const Int& operator++() {++member; return *this; } // prefix ++ increment operator
    const Int operator++(int) {Int Old_value(*this); ++member; return Old_value; } // postfix ++ increment operator
    const Int& operator--() {--member; return *this; }  // prefix ++ increment operator
    const Int operator--(int) {Int Old_value(*this); --member; return Old_value; } // postfix ++ increment operator
private:
    int member;
};
//-------------------
// members
// assignment operator
Int& Int::operator=(const Int& i) { 
    if(this==&i) return *this;
    member = i.member;
    return *this;
}
//-------------------
// not members
// binary operator+
const Int operator+(const Int& left, const Int& right) {
    return Int(left.data()+right.data());
}
//-------------------
// binary operator-
const Int operator-(const Int& left, const Int& right) {
    return Int(left.data()-right.data());
}
//-------------------
// binary operator*
const Int operator*(const Int& left, const Int& right) {
    return Int(left.data()*right.data());
}
//-------------------
// binary operator/
const Int operator/(const Int& left, const Int& right) {
    return Int(left.data()/right.data());
}
//-------------------
// binary operator%
const Int operator%(const Int& left, const Int& right) {
    return Int(left.data()%right.data());
}
//-------------------
// operator>>
istream& operator>>(istream& is, Int& i) { 
        int n;
        is >> n;
        if (is) i.set_member(n);
        return is;
}
//-------------------
// operator<<
ostream& operator<<(ostream& os, const Int& i) {
        os << i.data();
        return os;
}
и второй (шаблонный класс на основе первого класса Int)
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
//-------------------------------------------------------
// class template<class T> Number
template<class T>
class Number {
public:
    // constructors
    Number(T n = 0) : member(n) { }
    Number(const Number& i) : member(i.member) { }
    Number& operator=(const Number& n);
    // access
    T data() const { return member; }
    // modyfication
    void set_member(T n) { member = n; }
    // operators
    const Number& operator+() {return *this; } // unary+ operator
    const Number operator-() {return Number(-member); }  //unary- operator
    const Number& operator++() {member++; return *this; } // prefix ++ increment operator
    const Number operator++(int) {Number Old_value(*this); member++; return Old_value; } // postfix ++ increment operator
    const Number& operator--() {member--; return *this; }  // prefix ++ increment operator
    const Number operator--(int) {Number Old_value(*this); member--; return Old_value; } // postfix ++ increment operator
private:
    T member;
};
//-------------------
// members
// assignment operator
template<class T>
Number<T>& Number<T>::operator=(const Number<T>& n) { 
    if(this==&n) return *this;
    member = n.member;
    return *this;
}
//-------------------
// not members
// binary operator+
template<class T>
const Number<T> operator+(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()+right.data());
}
//-------------------
// binary operator-
template<class T>
const Number<T> operator-(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()-right.data());
}
//-------------------
// binary operator*
template<class T>
const Number<T> operator*(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()*right.data());
}
//-------------------
// binary operator/
template<class T>
const Number<T> operator/(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()/right.data());
}
//-------------------
// binary operator%
template<class T>
const Number<T> operator%(const Number<T>& left, const Number<T>& right) {
    return Number<T>(left.data()%right.data());
}
//-------------------
// operator>>
template<class T>
istream& operator>>(istream& is, Number<T>& i) { 
        T n;
        is >> n;
        if (is) i.set_member(n);
        return is;
}
//-------------------
// operator<<
template<class T>
ostream& operator<<(ostream& os, const Number<T>& i) {
        os << i.data();
        return os;
}
Содержимое main()
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
int main()
{
        Int i(10);
    cout << -i << "; and value is " << i << endl;
    cout << --i << "; and value is " << i << endl;
    cout << +i << "; and value is " << i << endl;
    cout << ++i << "; and value is " << i << endl;
    cout << "postfix operators" << endl;
    cout << i++ << "; and value is " << i << endl;
    cout << i-- << "; and value is " << i << endl;
 
    cout << endl << "-----------------" << endl;
 
    Number<int> n1(100);
    Number<int> n2(5);
    cout << n1 << " % " << n2 << " == " <<n1%n2 << endl;
    cout << n1 << " / " << n2 << " == " <<n1/n2 << endl;
    cout << n1 << " * " << n2 << " == " <<n1*n2 << endl;
    cout << n1 << " - " << n2 << " == " <<n1-n2 << endl;
    cout << n1 << " + " << n2 << " == " <<n1+n2 << endl;
    
    cout << "n1 == 100; correct work:" << endl;
    cout << n1;
    cout << " prefix-- == " << --n1 << endl;
    cout << n1;
    cout << " postfix++ == " << n1++ << "; and n1 value == " << n1 << endl;
    cout << "----------------" << endl;
    
    cout << "n1 == 100; incorrect work:" << endl;
    cout << n1 << " prefix-- == " << --n1 << endl;
    cout << n1 << " postfix++ == " << n1++ << "; and n1 value == " << n1 << endl;
    
 
   return 0;
}
При выводе постфиксного и префиксного инкремента/декремента шаблонного класса Number используя поток cout и несколько операторов<<
C++
1
2
3
    cout << "n == 100; incorrect work:" << endl;
    cout << n1 << " prefix-- == " << --n1 << endl;
    cout << n1 << " postfix++ == " << n1++ << "; and n1 value == " << n1 << endl;
получаем несовсем то, что ожидалось.
Почему так?

Добавлено через 6 минут
Вывод:
correct work:
100 prefix-- == 99
99 postfix++ == 99; and n1 value == 100
----------------
incorrect work:
99 prefix-- == 99
100 postfix++ == 99; and n1 value == 100
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
27.08.2013, 12:29     Непонятный вывод: постфиксные и префиксные инкремент/декремент
Посмотрите здесь:

Постфиксные и префиксные *менты - C++
Только вчера узнал о существовании префиксного варианта декремента и инкремента: ++example; --example; И что-то это меня еще...

Префиксные/Постфиксные выражения - C++
Вводится одно из таких выражений. Как мне проверить каким именно это выражение является и как нормально считать знаки и числа для...

Префиксные и постфиксные операции инкремента и декремента + наследование - C++
Дано: Два класса(Counter и CountDn), следует при помощи наследования добавить функцию постфиксных операций. На то, что я набросал выдает...

Интересный вывод, инкремент и декремент в cout - C++
Привет. Вот есть след. код: int i = 0; std::cout &lt;&lt; i &lt;&lt; &quot; &quot; &lt;&lt; ++i &lt;&lt; std::endl; неожиданный вывод, но понять можно. Но вот этот я...

Инкремент(Декремент) - C++
Есть ли разница,какую употреблять форму:префиксную или постфиксную? Если на экран выводится одно и то же число в префиксной и постфиксной...

Потокобезопасен ли префиксный инкремент/декремент? - C++
Потокобезопасен ли префиксный инкремент/декремент? Например такой код: // Объявляем глобальную переменную uint64_t i=0; // Тут...

Инкремент и декремент в сложных выражениях - C++
Почему в следующем коде выведется 5, а не 4? Постфиксный инкремент не должен же влиять в данном случае на выводимую сумму. int i = 1; ...

Немного не понял ,написанное тут про инкремент и декремент - C++
Объясните на словах или на примерах .

Инкремент, декремент и прочее. A+++ - что означают это три плюса - C++
день добрый х) в задании попалась такая операция: a+++ = b%2 так вот. что, собственно, означают это три плюса?я знаю что есть инкремент, но...

Инкремент и вывод на консоль. Непонятное. - C++
Объясните, пожалуйста, почему, если так: int i = 5; cout &lt;&lt; i &lt;&lt; &quot; &quot;; cout &lt;&lt; ++i &lt;&lt; &quot;\n&quot;;, то на консоль выводится всё правильно: 5...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
loktionov272
8 / 8 / 1
Регистрация: 10.08.2013
Сообщений: 22
27.08.2013, 12:55     Непонятный вывод: постфиксные и префиксные инкремент/декремент #2
Цитата Сообщение от Cynacyn Посмотреть сообщение
получаем несовсем то, что ожидалось.
Почему так?
не следует более 1 раза в выражении(?) использовать одну и ту же переменную, если к ней применяется инкремент/декремент.
use:
C++
1
2
3
4
5
6
7
cout << n1;
cout << " prefix-- == " << --n1 << endl;
 
cout << n1;
 
cout << " postfix++ == " << n1++;
cout << "; and n1 value == " << n1 << endl;
Добавлено через 30 секунд

Не по теме:

иначе undefined behavior?



Добавлено через 4 минуты
http://ru.wikipedia.org/wiki/Неопределённое_поведение
SatanaXIII
Супер-модератор
Эксперт С++
5602 / 2636 / 242
Регистрация: 01.11.2011
Сообщений: 6,495
Завершенные тесты: 1
27.08.2013, 12:59     Непонятный вывод: постфиксные и префиксные инкремент/декремент #3
Цитата Сообщение от loktionov272 Посмотреть сообщение
не следует более 1 раза в выражении(?) использовать одну и ту же переменную, если к ней применяется инкремент/декремент.
Впринципе верно. Но исходит это из понятия точек следования.
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru