-
Notifications
You must be signed in to change notification settings - Fork 13
Expand file tree
/
Copy pathoperator-overloading.html
More file actions
592 lines (498 loc) · 144 KB
/
operator-overloading.html
File metadata and controls
592 lines (498 loc) · 144 KB
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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
<!DOCTYPE html>
<html lang="en-US">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>C++ | Operator Overloading</title>
<meta name="generator" content="VuePress 1.8.2">
<link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
<link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
<link rel="manifest" href="/site.webmanifest">
<link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
<link rel="mask-icon" href="/safari-pinned-tab.svg" color="#5bbad5">
<meta name="description" content="Array subscript operator, Arithmetic operators, Conversion operators, Complex Numbers Revisited, Unary operators, Comparison operators, Assignment operator, Named operators, Function call operator, Bitwise NOT operator, Bit shift operators for I/O">
<meta property="og:site_name" content="DevTut">
<meta property="og:title" content="C++ | Operator Overloading">
<meta property="og:description" content="Array subscript operator, Arithmetic operators, Conversion operators, Complex Numbers Revisited, Unary operators, Comparison operators, Assignment operator, Named operators, Function call operator, Bitwise NOT operator, Bit shift operators for I/O">
<meta property="og:type" content="article">
<meta property="og:url" content="/cpp/operator-overloading.html">
<meta property="og:image" content="/logo.png">
<meta name="twitter:title" content="C++ | Operator Overloading">
<meta name="twitter:description" content="Array subscript operator, Arithmetic operators, Conversion operators, Complex Numbers Revisited, Unary operators, Comparison operators, Assignment operator, Named operators, Function call operator, Bitwise NOT operator, Bit shift operators for I/O">
<meta name="twitter:url" content="/cpp/operator-overloading.html">
<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:image" content="/logo.png">
<meta name="theme-color" content="#ffffff">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<meta name="msapplication-TileImage" content="/mstile-150x150.png">
<meta name="msapplication-TileColor" content="#da532c">
<meta name="google-site-verification" content="76_rKXgwMVIjd-axJC_1zPV9OS4mEjvtgjYOWVkAdnQ">
<link rel="preload" href="/assets/css/0.styles.60619e34.css" as="style"><link rel="preload" href="/assets/js/app.1779e102.js" as="script"><link rel="preload" href="/assets/js/3.2cfa8016.js" as="script"><link rel="preload" href="/assets/js/683.89317374.js" as="script">
<link rel="stylesheet" href="/assets/css/0.styles.60619e34.css">
</head>
<body>
<div id="app" data-server-rendered="true"><div class="theme-container"><header class="navbar"><div class="sidebar-button"><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" viewBox="0 0 448 512" class="icon"><path fill="currentColor" d="M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"></path></svg></div> <a href="/" class="home-link router-link-active"><!----> <span class="site-name">DevTut</span></a> <div class="links"><form id="search-form" role="search" class="algolia-search-wrapper search-box"><input id="algolia-search-input" class="search-query"></form> <nav class="nav-links can-hide"> <a href="https://github.com/devtut/generate" target="_blank" rel="noopener noreferrer" class="repo-link">
GitHub
<span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></a></nav></div></header> <div class="sidebar-mask"></div> <aside class="sidebar"><nav class="nav-links"> <a href="https://github.com/devtut/generate" target="_blank" rel="noopener noreferrer" class="repo-link">
GitHub
<span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></a></nav> <ul class="sidebar-links"><li><section class="sidebar-group depth-0"><p class="sidebar-heading open"><span>C++</span> <!----></p> <ul class="sidebar-links sidebar-group-items"><li><a href="/cpp/" aria-current="page" class="sidebar-link">Disclaimer</a></li><li><a href="/cpp/getting-started-with-cpp.html" class="sidebar-link">Getting started with C++</a></li><li><a href="/cpp/literals.html" class="sidebar-link">Literals</a></li><li><a href="/cpp/operator-precedence.html" class="sidebar-link">operator precedence</a></li><li><a href="/cpp/floating-point-arithmetic.html" class="sidebar-link">Floating Point Arithmetic</a></li><li><a href="/cpp/bit-operators.html" class="sidebar-link">Bit Operators</a></li><li><a href="/cpp/bit-manipulation.html" class="sidebar-link">Bit Manipulation</a></li><li><a href="/cpp/bit-fields.html" class="sidebar-link">Bit fields</a></li><li><a href="/cpp/arrays.html" class="sidebar-link">Arrays</a></li><li><a href="/cpp/iterators.html" class="sidebar-link">Iterators</a></li><li><a href="/cpp/basic-input-output-in-c.html" class="sidebar-link">Basic input/output in c++</a></li><li><a href="/cpp/loops.html" class="sidebar-link">Loops</a></li><li><a href="/cpp/file-i-o.html" class="sidebar-link">File I/O</a></li><li><a href="/cpp/cpp-streams.html" class="sidebar-link">C++ Streams</a></li><li><a href="/cpp/stream-manipulators.html" class="sidebar-link">Stream manipulators</a></li><li><a href="/cpp/flow-control.html" class="sidebar-link">Flow Control</a></li><li><a href="/cpp/metaprogramming.html" class="sidebar-link">Metaprogramming</a></li><li><a href="/cpp/const-keyword.html" class="sidebar-link">const keyword</a></li><li><a href="/cpp/mutable-keyword.html" class="sidebar-link">mutable keyword</a></li><li><a href="/cpp/friend-keyword.html" class="sidebar-link">Friend keyword</a></li><li><a href="/cpp/type-keywords.html" class="sidebar-link">Type Keywords</a></li><li><a href="/cpp/basic-type-keywords.html" class="sidebar-link">Basic Type Keywords</a></li><li><a href="/cpp/variable-declaration-keywords.html" class="sidebar-link">Variable Declaration Keywords</a></li><li><a href="/cpp/keywords.html" class="sidebar-link">Keywords</a></li><li><a href="/cpp/returning-several-values-from-a-function.html" class="sidebar-link">Returning several values from a function</a></li><li><a href="/cpp/polymorphism.html" class="sidebar-link">Polymorphism</a></li><li><a href="/cpp/references.html" class="sidebar-link">References</a></li><li><a href="/cpp/value-and-reference-semantics.html" class="sidebar-link">Value and Reference Semantics</a></li><li><a href="/cpp/c-function-call-by-value-vs-call-by-reference.html" class="sidebar-link">C++ function "call by value" vs. "call by reference"</a></li><li><a href="/cpp/copying-vs-assignment.html" class="sidebar-link">Copying vs Assignment</a></li><li><a href="/cpp/pointers.html" class="sidebar-link">Pointers</a></li><li><a href="/cpp/pointers-to-members.html" class="sidebar-link">Pointers to members</a></li><li><a href="/cpp/the-this-pointer.html" class="sidebar-link">The This Pointer</a></li><li><a href="/cpp/smart-pointers.html" class="sidebar-link">Smart Pointers</a></li><li><a href="/cpp/classes-structures.html" class="sidebar-link">Classes/Structures</a></li><li><a href="/cpp/function-overloading.html" class="sidebar-link">Function Overloading</a></li><li><a href="/cpp/operator-overloading.html" aria-current="page" class="active sidebar-link">Operator Overloading</a><ul class="sidebar-sub-headers"><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#array-subscript-operator" class="sidebar-link">Array subscript operator</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#arithmetic-operators" class="sidebar-link">Arithmetic operators</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#conversion-operators" class="sidebar-link">Conversion operators</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#complex-numbers-revisited" class="sidebar-link">Complex Numbers Revisited</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#unary-operators" class="sidebar-link">Unary operators</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#comparison-operators" class="sidebar-link">Comparison operators</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#assignment-operator" class="sidebar-link">Assignment operator</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#named-operators" class="sidebar-link">Named operators</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#function-call-operator" class="sidebar-link">Function call operator</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#bitwise-not-operator" class="sidebar-link">Bitwise NOT operator</a></li><li class="sidebar-sub-header"><a href="/cpp/operator-overloading.html#bit-shift-operators-for-i-o" class="sidebar-link">Bit shift operators for I/O</a></li></ul></li><li><a href="/cpp/function-template-overloading.html" class="sidebar-link">Function Template Overloading</a></li><li><a href="/cpp/virtual-member-functions.html" class="sidebar-link">Virtual Member Functions</a></li><li><a href="/cpp/inline-functions.html" class="sidebar-link">Inline functions</a></li><li><a href="/cpp/special-member-functions.html" class="sidebar-link">Special Member Functions</a></li><li><a href="/cpp/non-static-member-functions.html" class="sidebar-link">Non-Static Member Functions</a></li><li><a href="/cpp/constant-class-member-functions.html" class="sidebar-link">Constant class member functions</a></li><li><a href="/cpp/c-containers.html" class="sidebar-link">C++ Containers</a></li><li><a href="/cpp/namespaces.html" class="sidebar-link">Namespaces</a></li><li><a href="/cpp/header-files.html" class="sidebar-link">Header Files</a></li><li><a href="/cpp/using-declaration.html" class="sidebar-link">Using declaration</a></li><li><a href="/cpp/std-string.html" class="sidebar-link">std::string</a></li><li><a href="/cpp/std-array.html" class="sidebar-link">std::array</a></li><li><a href="/cpp/std-vector.html" class="sidebar-link">std::vector</a></li><li><a href="/cpp/std-map.html" class="sidebar-link">std::map</a></li><li><a href="/cpp/std-optional.html" class="sidebar-link">std::optional</a></li><li><a href="/cpp/std-function-to-wrap-any-element-that-is-callable.html" class="sidebar-link">std::function: To wrap any element that is callable</a></li><li><a href="/cpp/std-forward-list.html" class="sidebar-link">std::forward_list</a></li><li><a href="/cpp/std-pair.html" class="sidebar-link">std::pair</a></li><li><a href="/cpp/std-atomics.html" class="sidebar-link">std::atomics</a></li><li><a href="/cpp/std-variant.html" class="sidebar-link">std::variant</a></li><li><a href="/cpp/std-iomanip.html" class="sidebar-link">std::iomanip</a></li><li><a href="/cpp/std-any.html" class="sidebar-link">std::any</a></li><li><a href="/cpp/std-set-and-std-multiset.html" class="sidebar-link">std::set and std::multiset</a></li><li><a href="/cpp/std-integer-sequence.html" class="sidebar-link">std::integer_sequence</a></li><li><a href="/cpp/using-std-unordered-map.html" class="sidebar-link">Using std::unordered_map</a></li><li><a href="/cpp/standard-library-algorithms.html" class="sidebar-link">Standard Library Algorithms</a></li><li><a href="/cpp/the-iso-c-standard.html" class="sidebar-link">The ISO C++ Standard</a></li><li><a href="/cpp/inline-variables.html" class="sidebar-link">Inline variables</a></li><li><a href="/cpp/random-number-generation.html" class="sidebar-link">Random number generation</a></li><li><a href="/cpp/date-and-time-using-chrono-header.html" class="sidebar-link">Date and time using header</a></li><li><a href="/cpp/sorting.html" class="sidebar-link">Sorting</a></li><li><a href="/cpp/enumeration.html" class="sidebar-link">Enumeration</a></li><li><a href="/cpp/iteration.html" class="sidebar-link">Iteration</a></li><li><a href="/cpp/regular-expressions.html" class="sidebar-link">Regular expressions</a></li><li><a href="/cpp/implementation-defined-behavior.html" class="sidebar-link">Implementation-defined behavior</a></li><li><a href="/cpp/exceptions.html" class="sidebar-link">Exceptions</a></li><li><a href="/cpp/lambdas.html" class="sidebar-link">Lambdas</a></li><li><a href="/cpp/value-categories.html" class="sidebar-link">Value Categories</a></li><li><a href="/cpp/preprocessor.html" class="sidebar-link">Preprocessor</a></li><li><a href="/cpp/data-structures-in-c.html" class="sidebar-link">Data Structures in C++</a></li><li><a href="/cpp/templates.html" class="sidebar-link">Templates</a></li><li><a href="/cpp/expression-templates.html" class="sidebar-link">Expression templates</a></li><li><a href="/cpp/curiously-recurring-template-pattern-crtp.html" class="sidebar-link">Curiously Recurring Template Pattern (CRTP)</a></li><li><a href="/cpp/threading.html" class="sidebar-link">Threading</a></li><li><a href="/cpp/thread-synchronization-structures.html" class="sidebar-link">Thread synchronization structures</a></li><li><a href="/cpp/the-rule-of-three-five-and-zero.html" class="sidebar-link">The Rule of Three, Five, And Zero</a></li><li><a href="/cpp/raii-resource-acquisition-is-initialization.html" class="sidebar-link">RAII: Resource Acquisition Is Initialization</a></li><li><a href="/cpp/rtti-run-time-type-information.html" class="sidebar-link">RTTI: Run-Time Type Information</a></li><li><a href="/cpp/mutexes.html" class="sidebar-link">Mutexes</a></li><li><a href="/cpp/recursive-mutex.html" class="sidebar-link">Recursive Mutex</a></li><li><a href="/cpp/semaphore.html" class="sidebar-link">Semaphore</a></li><li><a href="/cpp/futures-and-promises.html" class="sidebar-link">Futures and Promises</a></li><li><a href="/cpp/atomic-types.html" class="sidebar-link">Atomic Types</a></li><li><a href="/cpp/type-erasure.html" class="sidebar-link">Type Erasure</a></li><li><a href="/cpp/explicit-type-conversions.html" class="sidebar-link">Explicit type conversions</a></li><li><a href="/cpp/unnamed-types.html" class="sidebar-link">Unnamed types</a></li><li><a href="/cpp/type-traits.html" class="sidebar-link">Type Traits</a></li><li><a href="/cpp/return-type-covariance.html" class="sidebar-link">Return Type Covariance</a></li><li><a href="/cpp/layout-of-object-types.html" class="sidebar-link">Layout of object types</a></li><li><a href="/cpp/type-inference.html" class="sidebar-link">Type Inference</a></li><li><a href="/cpp/typedef-and-type-aliases.html" class="sidebar-link">Typedef and type aliases</a></li><li><a href="/cpp/type-deduction.html" class="sidebar-link">type deduction</a></li><li><a href="/cpp/trailing-return-type.html" class="sidebar-link">Trailing return type</a></li><li><a href="/cpp/alignment.html" class="sidebar-link">Alignment</a></li><li><a href="/cpp/perfect-forwarding.html" class="sidebar-link">Perfect Forwarding</a></li><li><a href="/cpp/decltype.html" class="sidebar-link">decltype</a></li><li><a href="/cpp/sfinae-substitution-failure-is-not-an-error.html" class="sidebar-link">SFINAE (Substitution Failure Is Not An Error)</a></li><li><a href="/cpp/undefined-behavior.html" class="sidebar-link">Undefined Behavior</a></li><li><a href="/cpp/overload-resolution.html" class="sidebar-link">Overload resolution</a></li><li><a href="/cpp/move-semantics.html" class="sidebar-link">Move Semantics</a></li><li><a href="/cpp/pimpl-idiom.html" class="sidebar-link">Pimpl Idiom</a></li><li><a href="/cpp/auto.html" class="sidebar-link">auto</a></li><li><a href="/cpp/copy-elision.html" class="sidebar-link">Copy Elision</a></li><li><a href="/cpp/fold-expressions.html" class="sidebar-link">Fold Expressions</a></li><li><a href="/cpp/unions.html" class="sidebar-link">Unions</a></li><li><a href="/cpp/design-pattern-implementation-in-c.html" class="sidebar-link">Design pattern implementation in C++</a></li><li><a href="/cpp/singleton-design-pattern.html" class="sidebar-link">Singleton Design Pattern</a></li><li><a href="/cpp/user-defined-literals.html" class="sidebar-link">User-Defined Literals</a></li><li><a href="/cpp/memory-management.html" class="sidebar-link">Memory management</a></li><li><a href="/cpp/c-11-memory-model.html" class="sidebar-link">C++11 Memory Model</a></li><li><a href="/cpp/scopes.html" class="sidebar-link">Scopes</a></li><li><a href="/cpp/static-assert.html" class="sidebar-link">static_assert</a></li><li><a href="/cpp/constexpr.html" class="sidebar-link">constexpr</a></li><li><a href="/cpp/one-definition-rule-odr.html" class="sidebar-link">One Definition Rule (ODR)</a></li><li><a href="/cpp/unspecified-behavior.html" class="sidebar-link">Unspecified behavior</a></li><li><a href="/cpp/argument-dependent-name-lookup.html" class="sidebar-link">Argument Dependent Name Lookup</a></li><li><a href="/cpp/attributes.html" class="sidebar-link">Attributes</a></li><li><a href="/cpp/recursion-in-c.html" class="sidebar-link">Recursion in C++</a></li><li><a href="/cpp/arithmitic-metaprogramming.html" class="sidebar-link">Arithmitic Metaprogramming</a></li><li><a href="/cpp/callable-objects.html" class="sidebar-link">Callable Objects</a></li><li><a href="/cpp/client-server-examples.html" class="sidebar-link">Client server examples</a></li><li><a href="/cpp/const-correctness.html" class="sidebar-link">Const Correctness</a></li><li><a href="/cpp/parameter-packs.html" class="sidebar-link">Parameter packs</a></li><li><a href="/cpp/build-systems.html" class="sidebar-link">Build Systems</a></li><li><a href="/cpp/concurrency-with-openmp.html" class="sidebar-link">Concurrency With OpenMP</a></li><li><a href="/cpp/resource-management.html" class="sidebar-link">Resource Management</a></li><li><a href="/cpp/storage-class-specifiers.html" class="sidebar-link">Storage class specifiers</a></li><li><a href="/cpp/linkage-specifications.html" class="sidebar-link">Linkage specifications</a></li><li><a href="/cpp/digit-separators.html" class="sidebar-link">Digit separators</a></li><li><a href="/cpp/c-incompatibilities.html" class="sidebar-link">C incompatibilities</a></li><li><a href="/cpp/side-by-side-comparisons-of-classic-c-examples-solved-via-c-vs-c-11-vs-c-14-vs-c-17.html" class="sidebar-link">Side by Side Comparisons of classic C++ examples solved via C++ vs C++11 vs C++14 vs C++17</a></li><li><a href="/cpp/compiling-and-building.html" class="sidebar-link">Compiling and Building</a></li><li><a href="/cpp/common-compile-linker-errors-gcc.html" class="sidebar-link">Common compile/linker errors (GCC)</a></li><li><a href="/cpp/more-undefined-behaviors-in-c.html" class="sidebar-link">More undefined behaviors in C++</a></li><li><a href="/cpp/unit-testing-in-c.html" class="sidebar-link">Unit Testing in C++</a></li><li><a href="/cpp/c-debugging-and-debug-prevention-tools-techniques.html" class="sidebar-link">C++ Debugging and Debug-prevention Tools & Techniques</a></li><li><a href="/cpp/optimization-in-c.html" class="sidebar-link">Optimization in C++</a></li><li><a href="/cpp/optimization.html" class="sidebar-link">Optimization</a></li><li><a href="/cpp/profiling.html" class="sidebar-link">Profiling</a></li><li><a href="/cpp/refactoring-techniques.html" class="sidebar-link">Refactoring Techniques</a></li><li><a href="/cpp/internationalization-in-c.html" class="sidebar-link">Internationalization in C++</a></li><li><a href="/cpp/contributors.html" class="sidebar-link">The Contributors</a></li></ul></section></li></ul> </aside> <main class="page"> <div class="theme-default-content content__default"><h1 id="operator-overloading"><a href="#operator-overloading" class="header-anchor">#</a> Operator Overloading</h1> <p>In C++, it is possible to define operators such as <code>+</code> and <code>-></code> for user-defined types. For example, the <code><string></code> header defines a <code>+</code> operator to concatenate strings. This is done by defining an <strong>operator function</strong> using the <code>operator</code> <a href="http://stackoverflow.com/documentation/c%2b%2b/4891/keywords" target="_blank" rel="noopener noreferrer">keyword<span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></a>.</p> <h2 id="array-subscript-operator"><a href="#array-subscript-operator" class="header-anchor">#</a> Array subscript operator</h2> <p>You can even overload the array subscript operator <code>[]</code>.</p> <p>You should <strong>always</strong> (99.98% of the time) implement 2 versions, a <code>const</code> and a not-<code>const</code> version, because if the object is <code>const</code>, it should not be able to modify the object returned by <code>[]</code>.</p> <p>The arguments are passed by <code>const&</code> instead of by value because passing by reference is faster than by value, and <code>const</code> so that the operator doesn't change the index accidentally.</p> <p>The operators return by reference, because by design you can modify the object <code>[]</code> return, i.e:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code>std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span><span class="token keyword">int</span><span class="token operator">></span> v<span class="token punctuation">{</span> <span class="token number">1</span> <span class="token punctuation">}</span><span class="token punctuation">;</span>
v<span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span> <span class="token operator">=</span> <span class="token number">2</span><span class="token punctuation">;</span> <span class="token comment">//Changes value of 1 to 2</span>
<span class="token comment">//wouldn't be possible if not returned by reference</span>
</code></pre></div><p>You can <strong>only</strong> overload inside a <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//I is the index type, normally an int</span>
T<span class="token operator">&</span> <span class="token keyword">operator</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">const</span> I<span class="token operator">&</span> index<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">//Do something</span>
<span class="token comment">//return something</span>
<span class="token punctuation">}</span>
<span class="token comment">//I is the index type, normally an int</span>
<span class="token keyword">const</span> T<span class="token operator">&</span> <span class="token keyword">operator</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">const</span> I<span class="token operator">&</span> index<span class="token punctuation">)</span> <span class="token keyword">const</span>
<span class="token punctuation">{</span>
<span class="token comment">//Do something</span>
<span class="token comment">//return something</span>
<span class="token punctuation">}</span>
</code></pre></div><p>Multiple subscript operators, <code>[][]...</code>, can be achieved via proxy objects. The following example of a simple row-major matrix class demonstrates this:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token operator">></span>
<span class="token keyword">class</span> <span class="token class-name">matrix</span> <span class="token punctuation">{</span>
<span class="token comment">// class enabling [][] overload to access matrix elements</span>
<span class="token keyword">template</span> <span class="token operator"><</span><span class="token keyword">class</span> <span class="token class-name">C</span><span class="token operator">></span>
<span class="token keyword">class</span> <span class="token class-name">proxy_row_vector</span> <span class="token punctuation">{</span>
<span class="token keyword">using</span> reference <span class="token operator">=</span> <span class="token keyword">decltype</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">declval</span><span class="token generic class-name"><span class="token operator"><</span>C<span class="token operator">></span></span></span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">using</span> const_reference <span class="token operator">=</span> <span class="token keyword">decltype</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">declval</span><span class="token generic class-name"><span class="token operator"><</span>C <span class="token keyword">const</span><span class="token operator">></span></span></span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">public</span><span class="token operator">:</span>
<span class="token function">proxy_row_vector</span><span class="token punctuation">(</span>C<span class="token operator">&</span> _vec<span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span>size_t _r_ind<span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span>size_t _cols<span class="token punctuation">)</span>
<span class="token operator">:</span> <span class="token function">vec</span><span class="token punctuation">(</span>_vec<span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">row_index</span><span class="token punctuation">(</span>_r_ind<span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">cols</span><span class="token punctuation">(</span>_cols<span class="token punctuation">)</span> <span class="token punctuation">{</span><span class="token punctuation">}</span>
const_reference <span class="token keyword">operator</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span>size_t _col_index<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span>
<span class="token keyword">return</span> vec<span class="token punctuation">[</span>row_index<span class="token operator">*</span>cols <span class="token operator">+</span> _col_index<span class="token punctuation">]</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
reference <span class="token keyword">operator</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span>size_t _col_index<span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">return</span> vec<span class="token punctuation">[</span>row_index<span class="token operator">*</span>cols <span class="token operator">+</span> _col_index<span class="token punctuation">]</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">private</span><span class="token operator">:</span>
C<span class="token operator">&</span> vec<span class="token punctuation">;</span>
std<span class="token double-colon punctuation">::</span>size_t row_index<span class="token punctuation">;</span> <span class="token comment">// row index to access</span>
std<span class="token double-colon punctuation">::</span>size_t cols<span class="token punctuation">;</span> <span class="token comment">// number of columns in matrix</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">using</span> const_proxy <span class="token operator">=</span> proxy_row_vector<span class="token operator"><</span><span class="token keyword">const</span> std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span>T<span class="token operator">>></span><span class="token punctuation">;</span>
<span class="token keyword">using</span> proxy <span class="token operator">=</span> proxy_row_vector<span class="token operator"><</span>std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span>T<span class="token operator">>></span><span class="token punctuation">;</span>
<span class="token keyword">public</span><span class="token operator">:</span>
<span class="token function">matrix</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">:</span> <span class="token function">mtx</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">rows</span><span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">cols</span><span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">)</span> <span class="token punctuation">{</span><span class="token punctuation">}</span>
<span class="token function">matrix</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span>size_t _rows<span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span>size_t _cols<span class="token punctuation">)</span>
<span class="token operator">:</span> <span class="token function">mtx</span><span class="token punctuation">(</span>_rows<span class="token operator">*</span>_cols<span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">rows</span><span class="token punctuation">(</span>_rows<span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">cols</span><span class="token punctuation">(</span>_cols<span class="token punctuation">)</span> <span class="token punctuation">{</span><span class="token punctuation">}</span>
<span class="token comment">// call operator[] followed by another [] call to access matrix elements</span>
const_proxy <span class="token keyword">operator</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span>size_t _row_index<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token function">const_proxy</span><span class="token punctuation">(</span>mtx<span class="token punctuation">,</span> _row_index<span class="token punctuation">,</span> cols<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
proxy <span class="token keyword">operator</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span>size_t _row_index<span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token function">proxy</span><span class="token punctuation">(</span>mtx<span class="token punctuation">,</span> _row_index<span class="token punctuation">,</span> cols<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">private</span><span class="token operator">:</span>
std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span>T<span class="token operator">></span> mtx<span class="token punctuation">;</span>
std<span class="token double-colon punctuation">::</span>size_t rows<span class="token punctuation">;</span>
std<span class="token double-colon punctuation">::</span>size_t cols<span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
</code></pre></div><h2 id="arithmetic-operators"><a href="#arithmetic-operators" class="header-anchor">#</a> Arithmetic operators</h2> <p>You can overload all basic arithmetic operators:</p> <ul><li><code>+</code> and <code>+=</code></li> <li><code>-</code> and <code>-=</code></li> <li><code>*</code> and <code>*=</code></li> <li><code>/</code> and <code>/=</code></li> <li><code>&</code> and <code>&=</code></li> <li><code>|</code> and <code>|=</code></li> <li><code>^</code> and <code>^=</code></li> <li><code>>></code> and <code>>>=</code></li> <li><code><<</code> and <code><<=</code></li></ul> <p>Overloading for all operators is the same. <em>Scroll down for explanation</em></p> <p>Overloading outside of <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//operator+ should be implemented in terms of operator+=</span>
T <span class="token keyword">operator</span><span class="token operator">+</span><span class="token punctuation">(</span>T lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
lhs <span class="token operator">+=</span> rhs<span class="token punctuation">;</span>
<span class="token keyword">return</span> lhs<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
T<span class="token operator">&</span> <span class="token keyword">operator</span><span class="token operator">+=</span><span class="token punctuation">(</span>T<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">//Perform addition</span>
<span class="token keyword">return</span> lhs<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><p>Overloading inside of <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//operator+ should be implemented in terms of operator+=</span>
T <span class="token keyword">operator</span><span class="token operator">+</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token operator">*</span><span class="token keyword">this</span> <span class="token operator">+=</span> rhs<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
T<span class="token operator">&</span> <span class="token keyword">operator</span><span class="token operator">+=</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">//Perform addition</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><p>Note: <code>operator+</code> should return by non-const value, as returning a reference wouldn't make sense (it returns a <em>new</em> object) nor would returning a <code>const</code> value (you should generally not return by <code>const</code>). The first argument is passed by value, why? Because</p> <ol><li>You can't modify the original object (<code>Object foobar = foo + bar;</code> shouldn't modify <code>foo</code> after all, it wouldn't make sense)</li> <li>You can't make it <code>const</code>, because you will have to be able to modify the object (because <code>operator+</code> is implemented in terms of <code>operator+=</code>, which modifies the object)</li></ol> <p>Passing by <code>const&</code> would be an option, but then you will have to make a temporary copy of the passed object. By passing by value, the compiler does it for you.</p> <p><code>operator+=</code> returns a reference to the itself, because it is then possible to chain them (don't use the same variable though, that would be undefined behavior due to sequence points).</p> <p>The first argument is a reference (we want to modify it), but not <code>const</code>, because then you wouldn't be able to modify it. The second argument should not be modified, and so for performance reason is passed by <code>const&</code> (passing by const reference is faster than by value).</p> <h2 id="conversion-operators"><a href="#conversion-operators" class="header-anchor">#</a> Conversion operators</h2> <p>You can overload type operators, so that your type can be implicitly converted into the specified type.</p> <p>The conversion operator <strong>must</strong> be defined in a <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">operator</span> <span class="token function">T</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span> <span class="token comment">/* return something */</span> <span class="token punctuation">}</span>
</code></pre></div><p><em>Note: the operator is <code>const</code> to allow <code>const</code> objects to be converted.</em></p> <p>Example:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">struct</span> <span class="token class-name">Text</span>
<span class="token punctuation">{</span>
std<span class="token double-colon punctuation">::</span>string text<span class="token punctuation">;</span>
<span class="token comment">// Now Text can be implicitly converted into a const char*</span>
<span class="token comment">/*explicit*/</span> <span class="token keyword">operator</span> <span class="token keyword">const</span> <span class="token keyword">char</span><span class="token operator">*</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> text<span class="token punctuation">.</span><span class="token function">data</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token comment">// ^^^^^^^</span>
<span class="token comment">// to disable implicit conversion</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
Text t<span class="token punctuation">;</span>
t<span class="token punctuation">.</span>text <span class="token operator">=</span> <span class="token string">"Hello world!"</span><span class="token punctuation">;</span>
<span class="token comment">//Ok</span>
<span class="token keyword">const</span> <span class="token keyword">char</span><span class="token operator">*</span> copyoftext <span class="token operator">=</span> t<span class="token punctuation">;</span>
</code></pre></div><h2 id="complex-numbers-revisited"><a href="#complex-numbers-revisited" class="header-anchor">#</a> Complex Numbers Revisited</h2> <p>The code below implements a very simple complex number type for which the underlying field is automatically promoted, following the language's type promotion rules, under application of the four basic operators (+, -, *, and /) with a member of a different field (be it another <code>complex<T></code> or some scalar type).</p> <p>This is intended to be a holistic example covering operator overloading alongside basic use of templates.</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token macro property"><span class="token directive-hash">#</span><span class="token directive keyword">include</span> <span class="token string"><type_traits></span></span>
<span class="token keyword">namespace</span> not_std<span class="token punctuation">{</span>
<span class="token keyword">using</span> std<span class="token double-colon punctuation">::</span>decay_t<span class="token punctuation">;</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token comment">// complex< value_t ></span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">value_t</span><span class="token operator">></span>
<span class="token keyword">struct</span> <span class="token class-name">complex</span>
<span class="token punctuation">{</span>
value_t x<span class="token punctuation">;</span>
value_t y<span class="token punctuation">;</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">+=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> value_t <span class="token operator">&</span>x<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">this</span><span class="token operator">-></span>x <span class="token operator">+=</span> x<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">+=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex <span class="token operator">&</span>other<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">this</span><span class="token operator">-></span>x <span class="token operator">+=</span> other<span class="token punctuation">.</span>x<span class="token punctuation">;</span>
<span class="token keyword">this</span><span class="token operator">-></span>y <span class="token operator">+=</span> other<span class="token punctuation">.</span>y<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">-=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> value_t <span class="token operator">&</span>x<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">this</span><span class="token operator">-></span>x <span class="token operator">-=</span> x<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">-=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex <span class="token operator">&</span>other<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">this</span><span class="token operator">-></span>x <span class="token operator">-=</span> other<span class="token punctuation">.</span>x<span class="token punctuation">;</span>
<span class="token keyword">this</span><span class="token operator">-></span>y <span class="token operator">-=</span> other<span class="token punctuation">.</span>y<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">*=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> value_t <span class="token operator">&</span>s<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">this</span><span class="token operator">-></span>x <span class="token operator">*=</span> s<span class="token punctuation">;</span>
<span class="token keyword">this</span><span class="token operator">-></span>y <span class="token operator">*=</span> s<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">*=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex <span class="token operator">&</span>other<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">)</span> <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">)</span> <span class="token operator">*</span> other<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">/=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> value_t <span class="token operator">&</span>s<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">this</span><span class="token operator">-></span>x <span class="token operator">/=</span> s<span class="token punctuation">;</span>
<span class="token keyword">this</span><span class="token operator">-></span>y <span class="token operator">/=</span> s<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">/=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex <span class="token operator">&</span>other<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">)</span> <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">)</span> <span class="token operator">/</span> other<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token function">complex</span><span class="token punctuation">(</span><span class="token keyword">const</span> value_t <span class="token operator">&</span>x<span class="token punctuation">,</span> <span class="token keyword">const</span> value_t <span class="token operator">&</span>y<span class="token punctuation">)</span>
<span class="token operator">:</span> x<span class="token punctuation">{</span>x<span class="token punctuation">}</span>
<span class="token punctuation">,</span> y<span class="token punctuation">{</span>y<span class="token punctuation">}</span>
<span class="token punctuation">{</span><span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">other_value_t</span><span class="token operator">></span>
<span class="token keyword">explicit</span> <span class="token function">complex</span><span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>other_value_t<span class="token operator">></span> <span class="token operator">&</span>other<span class="token punctuation">)</span>
<span class="token operator">:</span> x<span class="token punctuation">{</span><span class="token generic-function"><span class="token function">static_cast</span><span class="token generic class-name"><span class="token operator"><</span><span class="token keyword">const</span> value_t <span class="token operator">&</span><span class="token operator">></span></span></span><span class="token punctuation">(</span>other<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token punctuation">}</span>
<span class="token punctuation">,</span> y<span class="token punctuation">{</span><span class="token generic-function"><span class="token function">static_cast</span><span class="token generic class-name"><span class="token operator"><</span><span class="token keyword">const</span> value_t <span class="token operator">&</span><span class="token operator">></span></span></span><span class="token punctuation">(</span>other<span class="token punctuation">.</span>y<span class="token punctuation">)</span><span class="token punctuation">}</span>
<span class="token punctuation">{</span><span class="token punctuation">}</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">=</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex <span class="token operator">&</span><span class="token punctuation">)</span> <span class="token operator">=</span> <span class="token keyword">default</span><span class="token punctuation">;</span>
complex <span class="token operator">&</span><span class="token keyword">operator</span> <span class="token operator">=</span> <span class="token punctuation">(</span>complex <span class="token operator">&&</span><span class="token punctuation">)</span> <span class="token operator">=</span> <span class="token keyword">default</span><span class="token punctuation">;</span>
<span class="token function">complex</span><span class="token punctuation">(</span><span class="token keyword">const</span> complex <span class="token operator">&</span><span class="token punctuation">)</span> <span class="token operator">=</span> <span class="token keyword">default</span><span class="token punctuation">;</span>
<span class="token function">complex</span><span class="token punctuation">(</span>complex <span class="token operator">&&</span><span class="token punctuation">)</span> <span class="token operator">=</span> <span class="token keyword">default</span><span class="token punctuation">;</span>
<span class="token function">complex</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">=</span> <span class="token keyword">default</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token comment">// Absolute value squared</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">value_t</span><span class="token operator">></span>
value_t <span class="token function">absqr</span><span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>value_t<span class="token operator">></span> <span class="token operator">&</span>z<span class="token punctuation">)</span>
<span class="token punctuation">{</span> <span class="token keyword">return</span> z<span class="token punctuation">.</span>x<span class="token operator">*</span>z<span class="token punctuation">.</span>x <span class="token operator">+</span> z<span class="token punctuation">.</span>y<span class="token operator">*</span>z<span class="token punctuation">.</span>y<span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token comment">// operator - (negation)</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">value_t</span><span class="token operator">></span>
complex<span class="token operator"><</span>value_t<span class="token operator">></span> <span class="token keyword">operator</span> <span class="token operator">-</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>value_t<span class="token operator">></span> <span class="token operator">&</span>z<span class="token punctuation">)</span>
<span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token punctuation">{</span><span class="token operator">-</span>z<span class="token punctuation">.</span>x<span class="token punctuation">,</span> <span class="token operator">-</span>z<span class="token punctuation">.</span>y<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token comment">// operator +</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span><span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">+</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>left_t<span class="token operator">></span> <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> complex<span class="token operator"><</span>right_t<span class="token operator">></span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span>x <span class="token operator">+</span> b<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span><span class="token punctuation">{</span>a<span class="token punctuation">.</span>x <span class="token operator">+</span> b<span class="token punctuation">.</span>x<span class="token punctuation">,</span> a<span class="token punctuation">.</span>y <span class="token operator">+</span> b<span class="token punctuation">.</span>y<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span><span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">+</span> <span class="token punctuation">(</span><span class="token keyword">const</span> left_t <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> complex<span class="token operator"><</span>right_t<span class="token operator">></span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a <span class="token operator">+</span> b<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span><span class="token punctuation">{</span>a <span class="token operator">+</span> b<span class="token punctuation">.</span>x<span class="token punctuation">,</span> b<span class="token punctuation">.</span>y<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span><span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">+</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>left_t<span class="token operator">></span> <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> right_t <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span>x <span class="token operator">+</span> b<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span><span class="token punctuation">{</span>a<span class="token punctuation">.</span>x <span class="token operator">+</span> b<span class="token punctuation">,</span> a<span class="token punctuation">.</span>y<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token comment">// operator -</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span><span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">-</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>left_t<span class="token operator">></span> <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> complex<span class="token operator"><</span>right_t<span class="token operator">></span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span>x <span class="token operator">-</span> b<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span><span class="token punctuation">{</span>a<span class="token punctuation">.</span>x <span class="token operator">-</span> b<span class="token punctuation">.</span>x<span class="token punctuation">,</span> a<span class="token punctuation">.</span>y <span class="token operator">-</span> b<span class="token punctuation">.</span>y<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span><span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">-</span> <span class="token punctuation">(</span><span class="token keyword">const</span> left_t <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> complex<span class="token operator"><</span>right_t<span class="token operator">></span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a <span class="token operator">-</span> b<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span><span class="token punctuation">{</span>a <span class="token operator">-</span> b<span class="token punctuation">.</span>x<span class="token punctuation">,</span> <span class="token operator">-</span> b<span class="token punctuation">.</span>y<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span><span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">-</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>left_t<span class="token operator">></span> <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> right_t <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span>x <span class="token operator">-</span> b<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span><span class="token punctuation">{</span>a<span class="token punctuation">.</span>x <span class="token operator">-</span> b<span class="token punctuation">,</span> a<span class="token punctuation">.</span>y<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token comment">// operator *</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">*</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>left_t<span class="token operator">></span> <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> complex<span class="token operator"><</span>right_t<span class="token operator">></span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span>x <span class="token operator">*</span> b<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token punctuation">{</span>
a<span class="token punctuation">.</span>x<span class="token operator">*</span>b<span class="token punctuation">.</span>x <span class="token operator">-</span> a<span class="token punctuation">.</span>y<span class="token operator">*</span>b<span class="token punctuation">.</span>y<span class="token punctuation">,</span>
a<span class="token punctuation">.</span>x<span class="token operator">*</span>b<span class="token punctuation">.</span>y <span class="token operator">+</span> a<span class="token punctuation">.</span>y<span class="token operator">*</span>b<span class="token punctuation">.</span>x
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">*</span> <span class="token punctuation">(</span><span class="token keyword">const</span> left_t <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> complex<span class="token operator"><</span>right_t<span class="token operator">></span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a <span class="token operator">*</span> b<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token punctuation">{</span>a <span class="token operator">*</span> b<span class="token punctuation">.</span>x<span class="token punctuation">,</span> a <span class="token operator">*</span> b<span class="token punctuation">.</span>y<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">*</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>left_t<span class="token operator">></span> <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> right_t <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span>x <span class="token operator">*</span> b<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token punctuation">{</span>a<span class="token punctuation">.</span>x <span class="token operator">*</span> b<span class="token punctuation">,</span> a<span class="token punctuation">.</span>y <span class="token operator">*</span> b<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token comment">// operator /</span>
<span class="token comment">//----------------------------------------------------------------</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">/</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>left_t<span class="token operator">></span> <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> complex<span class="token operator"><</span>right_t<span class="token operator">></span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span>x <span class="token operator">/</span> b<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span>
<span class="token keyword">const</span> <span class="token keyword">auto</span> r <span class="token operator">=</span> <span class="token function">absqr</span><span class="token punctuation">(</span>b<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token punctuation">{</span>
<span class="token punctuation">(</span> a<span class="token punctuation">.</span>x<span class="token operator">*</span>b<span class="token punctuation">.</span>x <span class="token operator">+</span> a<span class="token punctuation">.</span>y<span class="token operator">*</span>b<span class="token punctuation">.</span>y<span class="token punctuation">)</span> <span class="token operator">/</span> r<span class="token punctuation">,</span>
<span class="token punctuation">(</span><span class="token operator">-</span>a<span class="token punctuation">.</span>x<span class="token operator">*</span>b<span class="token punctuation">.</span>y <span class="token operator">+</span> a<span class="token punctuation">.</span>y<span class="token operator">*</span>b<span class="token punctuation">.</span>x<span class="token punctuation">)</span> <span class="token operator">/</span> r
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">/</span> <span class="token punctuation">(</span><span class="token keyword">const</span> left_t <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> complex<span class="token operator"><</span>right_t<span class="token operator">></span> <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a <span class="token operator">/</span> b<span class="token punctuation">.</span>x<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span>
<span class="token keyword">const</span> <span class="token keyword">auto</span> s <span class="token operator">=</span> a<span class="token operator">/</span><span class="token function">absqr</span><span class="token punctuation">(</span>b<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token punctuation">{</span>
b<span class="token punctuation">.</span>x <span class="token operator">*</span> s<span class="token punctuation">,</span>
<span class="token operator">-</span>b<span class="token punctuation">.</span>y <span class="token operator">*</span> s
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">typename</span> <span class="token class-name">left_t</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">right_t</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span> <span class="token operator">/</span> <span class="token punctuation">(</span><span class="token keyword">const</span> complex<span class="token operator"><</span>left_t<span class="token operator">></span> <span class="token operator">&</span>a<span class="token punctuation">,</span> <span class="token keyword">const</span> right_t <span class="token operator">&</span>b<span class="token punctuation">)</span>
<span class="token operator">-></span> complex<span class="token operator"><</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span>x <span class="token operator">/</span> b<span class="token punctuation">)</span><span class="token operator">>></span>
<span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token punctuation">{</span>a<span class="token punctuation">.</span>x <span class="token operator">/</span> b<span class="token punctuation">,</span> a<span class="token punctuation">.</span>y <span class="token operator">/</span> b<span class="token punctuation">}</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token punctuation">}</span><span class="token comment">// namespace not_std</span>
<span class="token keyword">int</span> <span class="token function">main</span><span class="token punctuation">(</span><span class="token keyword">int</span> argc<span class="token punctuation">,</span> <span class="token keyword">char</span> <span class="token operator">*</span><span class="token operator">*</span>argv<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">using</span> <span class="token keyword">namespace</span> not_std<span class="token punctuation">;</span>
complex<span class="token operator"><</span><span class="token keyword">float</span><span class="token operator">></span> fz<span class="token punctuation">{</span><span class="token number">4.0f</span><span class="token punctuation">,</span> <span class="token number">1.0f</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token comment">// makes a complex<double></span>
<span class="token keyword">auto</span> dz <span class="token operator">=</span> fz <span class="token operator">*</span> <span class="token number">1.0</span><span class="token punctuation">;</span>
<span class="token comment">// still a complex<double></span>
<span class="token keyword">auto</span> idz <span class="token operator">=</span> <span class="token number">1.0f</span><span class="token operator">/</span>dz<span class="token punctuation">;</span>
<span class="token comment">// also a complex<double></span>
<span class="token keyword">auto</span> one <span class="token operator">=</span> dz <span class="token operator">*</span> idz<span class="token punctuation">;</span>
<span class="token comment">// a complex<double> again</span>
<span class="token keyword">auto</span> one_again <span class="token operator">=</span> fz <span class="token operator">*</span> idz<span class="token punctuation">;</span>
<span class="token comment">// Operator tests, just to make sure everything compiles.</span>
complex<span class="token operator"><</span><span class="token keyword">float</span><span class="token operator">></span> a<span class="token punctuation">{</span><span class="token number">1.0f</span><span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">2.0f</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
complex<span class="token operator"><</span><span class="token keyword">double</span><span class="token operator">></span> b<span class="token punctuation">{</span><span class="token number">3.0</span><span class="token punctuation">,</span> <span class="token operator">-</span><span class="token number">4.0</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token comment">// All of these are complex<double></span>
<span class="token keyword">auto</span> c0 <span class="token operator">=</span> a <span class="token operator">+</span> b<span class="token punctuation">;</span>
<span class="token keyword">auto</span> c1 <span class="token operator">=</span> a <span class="token operator">-</span> b<span class="token punctuation">;</span>
<span class="token keyword">auto</span> c2 <span class="token operator">=</span> a <span class="token operator">*</span> b<span class="token punctuation">;</span>
<span class="token keyword">auto</span> c3 <span class="token operator">=</span> a <span class="token operator">/</span> b<span class="token punctuation">;</span>
<span class="token comment">// All of these are complex<float></span>
<span class="token keyword">auto</span> d0 <span class="token operator">=</span> a <span class="token operator">+</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> d1 <span class="token operator">=</span> <span class="token number">1</span> <span class="token operator">+</span> a<span class="token punctuation">;</span>
<span class="token keyword">auto</span> d2 <span class="token operator">=</span> a <span class="token operator">-</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> d3 <span class="token operator">=</span> <span class="token number">1</span> <span class="token operator">-</span> a<span class="token punctuation">;</span>
<span class="token keyword">auto</span> d4 <span class="token operator">=</span> a <span class="token operator">*</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> d5 <span class="token operator">=</span> <span class="token number">1</span> <span class="token operator">*</span> a<span class="token punctuation">;</span>
<span class="token keyword">auto</span> d6 <span class="token operator">=</span> a <span class="token operator">/</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> d7 <span class="token operator">=</span> <span class="token number">1</span> <span class="token operator">/</span> a<span class="token punctuation">;</span>
<span class="token comment">// All of these are complex<double></span>
<span class="token keyword">auto</span> e0 <span class="token operator">=</span> b <span class="token operator">+</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> e1 <span class="token operator">=</span> <span class="token number">1</span> <span class="token operator">+</span> b<span class="token punctuation">;</span>
<span class="token keyword">auto</span> e2 <span class="token operator">=</span> b <span class="token operator">-</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> e3 <span class="token operator">=</span> <span class="token number">1</span> <span class="token operator">-</span> b<span class="token punctuation">;</span>
<span class="token keyword">auto</span> e4 <span class="token operator">=</span> b <span class="token operator">*</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> e5 <span class="token operator">=</span> <span class="token number">1</span> <span class="token operator">*</span> b<span class="token punctuation">;</span>
<span class="token keyword">auto</span> e6 <span class="token operator">=</span> b <span class="token operator">/</span> <span class="token number">1</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> e7 <span class="token operator">=</span> <span class="token number">1</span> <span class="token operator">/</span> b<span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><h2 id="unary-operators"><a href="#unary-operators" class="header-anchor">#</a> Unary operators</h2> <p>You can overload the 2 unary operators:</p> <ul><li><code>++foo</code> and <code>foo++</code></li> <li><code>--foo</code> and <code>foo--</code></li></ul> <p>Overloading is the same for both types (<code>++</code> and <code>--</code>). <em>Scroll down for explanation</em></p> <p>Overloading outside of <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//Prefix operator ++foo</span>
T<span class="token operator">&</span> <span class="token keyword">operator</span><span class="token operator">++</span><span class="token punctuation">(</span>T<span class="token operator">&</span> lhs<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">//Perform addition</span>
<span class="token keyword">return</span> lhs<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token comment">//Postfix operator foo++ (int argument is used to separate pre- and postfix) </span>
<span class="token comment">//Should be implemented in terms of ++foo (prefix operator)</span>
T <span class="token keyword">operator</span><span class="token operator">++</span><span class="token punctuation">(</span>T<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">int</span><span class="token punctuation">)</span>
<span class="token punctuation">{</span>
T <span class="token function">t</span><span class="token punctuation">(</span>lhs<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token operator">++</span>lhs<span class="token punctuation">;</span>
<span class="token keyword">return</span> t<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><p>Overloading inside of <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//Prefix operator ++foo</span>
T<span class="token operator">&</span> <span class="token keyword">operator</span><span class="token operator">++</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">//Perform addition</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token comment">//Postfix operator foo++ (int argument is used to separate pre- and postfix) </span>
<span class="token comment">//Should be implemented in terms of ++foo (prefix operator)</span>
T <span class="token keyword">operator</span><span class="token operator">++</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span>
<span class="token punctuation">{</span>
T <span class="token function">t</span><span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token operator">++</span><span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> t<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><p>Note: The prefix operator returns a reference to itself, so that you can continue operations on it. The first argument is a reference, as the prefix operator changes the object, that's also the reason why it isn't <code>const</code> (you wouldn't be able to modify it otherwise).</p> <p>The postfix operator returns by value a temporary (the previous value), and so it cannot be a reference, as it would be a reference to a temporary, which would be garbage value at the end of the function, because the temporary variable goes out of scope). It also cannot be <code>const</code>, because you should be able to modify it directly.</p> <p>The first argument is a non-<code>const</code> reference to the "calling" object, because if it were <code>const</code>, you wouldn't be able to modify it, and if it weren't a reference, you wouldn't change the original value.</p> <p>It is because of the copying needed in postfix operator overloads that it's better to make it a habit to use prefix ++ instead of postfix ++ in <code>for</code> loops. From the <code>for</code> loop perspective, they're usually functionally equivalent, but there might be a slight performance advantage to using prefix ++, especially with "fat" classes with a lot of members to copy. Example of using prefix ++ in a for loop:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">for</span> <span class="token punctuation">(</span>list<span class="token operator"><</span>string<span class="token operator">></span><span class="token double-colon punctuation">::</span>const_iterator it <span class="token operator">=</span> tokens<span class="token punctuation">.</span><span class="token function">begin</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
it <span class="token operator">!=</span> tokens<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token operator">++</span>it<span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token comment">// Don't use it++</span>
<span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>
<span class="token punctuation">}</span>
</code></pre></div><h2 id="comparison-operators"><a href="#comparison-operators" class="header-anchor">#</a> Comparison operators</h2> <p>You can overload all comparison operators:</p> <ul><li><code>==</code> and <code>!=</code></li> <li><code>></code> and <code><</code></li> <li><code>>=</code> and <code><=</code></li></ul> <p>The recommended way to overload all those operators is by implementing only 2 operators (<code>==</code> and <code><</code>) and then using those to define the rest. <em>Scroll down for explanation</em></p> <p>Overloading outside of <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//Only implement those 2</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">==</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token comment">/* Compare */</span> <span class="token punctuation">}</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator"><</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token comment">/* Compare */</span> <span class="token punctuation">}</span>
<span class="token comment">//Now you can define the rest</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">!=</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token operator">!</span><span class="token punctuation">(</span>lhs <span class="token operator">==</span> rhs<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">></span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> rhs <span class="token operator"><</span> lhs<span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator"><=</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token operator">!</span><span class="token punctuation">(</span>lhs <span class="token operator">></span> rhs<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">>=</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token operator">!</span><span class="token punctuation">(</span>lhs <span class="token operator"><</span> rhs<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
</code></pre></div><p>Overloading inside of <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//Note that the functions are const, because if they are not const, you wouldn't be able</span>
<span class="token comment">//to call them if the object is const</span>
<span class="token comment">//Only implement those 2</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">==</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span> <span class="token comment">/* Compare */</span> <span class="token punctuation">}</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator"><</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span> <span class="token comment">/* Compare */</span> <span class="token punctuation">}</span>
<span class="token comment">//Now you can define the rest</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">!=</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token operator">!</span><span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span> <span class="token operator">==</span> rhs<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">></span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> rhs <span class="token operator"><</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator"><=</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token operator">!</span><span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span> <span class="token operator">></span> rhs<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">bool</span> <span class="token keyword">operator</span><span class="token operator">>=</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> rhs<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token operator">!</span><span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span> <span class="token operator"><</span> rhs<span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
</code></pre></div><p>The operators obviously return a <code>bool</code>, indicating <code>true</code> or <code>false</code> for the corresponding operation.</p> <p>All of the operators take their arguments by <code>const&</code>, because the only thing that does operators do is compare, so they shouldn't modify the objects. Passing by <code>&</code> (reference) is faster than by value, and to make sure that the operators don't modify it, it is a <code>const</code>-reference.</p> <p>Note that the operators inside the <code>class</code>/<code>struct</code> are defined as <code>const</code>, the reason for this is that without the functions being <code>const</code>, comparing <code>const</code> objects would not be possible, as the compiler doesn't know that the operators don't modify anything.</p> <h2 id="assignment-operator"><a href="#assignment-operator" class="header-anchor">#</a> Assignment operator</h2> <p>The assignment operator is one of the most important operators because it allows you to change the status of a variable.</p> <p>If you do not overload the assigment operator for your <code>class</code>/<code>struct</code>, it is automatically generated by the compiler: the automatically-generated assignment operator performs a "memberwise assignment", ie by invoking assignment operators on all members, so that one object is copied to the other, a member at time.
The assignment operator should be overloaded when the simple memberwise assignment is not suitable for your <code>class</code>/<code>struct</code>, for example if you need to perform a <strong>deep copy</strong> of an object.</p> <p>Overloading the assignment operator <code>=</code> is easy, but you should follow some simple steps.</p> <li>**Test for self-assignment.** This check is important for two reasons:
<ul>
1. a self-assignment is a needless copy, so it does not make sense to perform it;
1. the next step will not work in the case of a self-assignment.
</ul></li>
1. **Clean the old data.** The old data must be replaced with new ones. Now, you can understand the second reason of the previous step: if the content of the object was destroyed, a self-assignment will fail to perform the copy.
1. **Copy all members.** If you overload the assigment operator for your `class` or your `struct`, it is not automatically generated by the compiler, so you will need to take charge of copying all members from the other object.
1. **Return** `*this`. The operator returns by itself by reference, because it allows chaining (i.e. `int b = (a = 6) + 4; //b == 10`).
<div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//T is some type</span>
T<span class="token operator">&</span> <span class="token keyword">operator</span><span class="token operator">=</span><span class="token punctuation">(</span><span class="token keyword">const</span> T<span class="token operator">&</span> other<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">//Do something (like copying values)</span>
<span class="token keyword">return</span> <span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><p><strong>Note:</strong> <code>other</code> is passed by <code>const&</code>, because the object being assigned should not be changed, and passing by reference is faster than by value, and to make sure than <code>operator=</code> doesn't modify it accidentally, it is <code>const</code>.</p> <p>The assignment operator can <strong>only</strong> to be overloaded in the <code>class</code>/<code>struct</code>, because the left value of <code>=</code> is <strong>always</strong> the <code>class</code>/<code>struct</code> itself. Defining it as a free function doesn't have this guarantee, and is disallowed because of that.</p> <p>When you declare it in the <code>class</code>/<code>struct</code>, the left value is implicitly the <code>class</code>/<code>struct</code> itself, so there is no problem with that.</p> <h2 id="named-operators"><a href="#named-operators" class="header-anchor">#</a> Named operators</h2> <p>You can extend C++ with named operators that are "quoted" by standard C++ operators.</p> <p>First we start with a dozen-line library:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">namespace</span> named_operator <span class="token punctuation">{</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">class</span> <span class="token class-name">D</span><span class="token operator">></span><span class="token keyword">struct</span> <span class="token class-name">make_operator</span><span class="token punctuation">{</span><span class="token keyword">constexpr</span> <span class="token function">make_operator</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token punctuation">,</span> <span class="token keyword">char</span><span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">O</span><span class="token operator">></span> <span class="token keyword">struct</span> <span class="token class-name">half_apply</span> <span class="token punctuation">{</span> T<span class="token operator">&&</span> lhs<span class="token punctuation">;</span> <span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">class</span> <span class="token class-name">Lhs</span><span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">Op</span><span class="token operator">></span>
half_apply<span class="token operator"><</span>Lhs<span class="token punctuation">,</span> <span class="token string">'*'</span><span class="token punctuation">,</span> Op<span class="token operator">></span> <span class="token keyword">operator</span><span class="token operator">*</span><span class="token punctuation">(</span> Lhs<span class="token operator">&&</span> lhs<span class="token punctuation">,</span> make_operator<span class="token operator"><</span>Op<span class="token operator">></span> <span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token punctuation">{</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator"><</span>Lhs<span class="token operator">></span></span></span><span class="token punctuation">(</span>lhs<span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">class</span> <span class="token class-name">Lhs</span><span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">Op</span><span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">Rhs</span><span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token keyword">operator</span><span class="token operator">*</span><span class="token punctuation">(</span> half_apply<span class="token operator"><</span>Lhs<span class="token punctuation">,</span> <span class="token string">'*'</span><span class="token punctuation">,</span> Op<span class="token operator">></span><span class="token operator">&&</span> lhs<span class="token punctuation">,</span> Rhs<span class="token operator">&&</span> rhs <span class="token punctuation">)</span>
<span class="token operator">-></span> <span class="token keyword">decltype</span><span class="token punctuation">(</span> <span class="token function">named_invoke</span><span class="token punctuation">(</span> std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator"><</span>Lhs<span class="token operator">></span></span></span><span class="token punctuation">(</span>lhs<span class="token punctuation">.</span>lhs<span class="token punctuation">)</span><span class="token punctuation">,</span> Op<span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator"><</span>Rhs<span class="token operator">></span></span></span><span class="token punctuation">(</span>rhs<span class="token punctuation">)</span> <span class="token punctuation">)</span> <span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token function">named_invoke</span><span class="token punctuation">(</span> std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator"><</span>Lhs<span class="token operator">></span></span></span><span class="token punctuation">(</span>lhs<span class="token punctuation">.</span>lhs<span class="token punctuation">)</span><span class="token punctuation">,</span> Op<span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">forward</span><span class="token generic class-name"><span class="token operator"><</span>Rhs<span class="token operator">></span></span></span><span class="token punctuation">(</span>rhs<span class="token punctuation">)</span> <span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</code></pre></div><p>this doesn't do anything yet.</p> <p>First, appending vectors</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">namespace</span> my_ns <span class="token punctuation">{</span>
<span class="token keyword">struct</span> <span class="token class-name">append_t</span> <span class="token operator">:</span> <span class="token base-clause">named_operator<span class="token double-colon punctuation">::</span><span class="token class-name">make_operator</span><span class="token operator"><</span><span class="token class-name">append_t</span><span class="token operator">></span></span> <span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">constexpr</span> append_t append<span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">class</span> <span class="token class-name">T</span><span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">A0</span><span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">A1</span><span class="token operator">></span>
std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span>T<span class="token punctuation">,</span> A0<span class="token operator">></span> <span class="token function">named_invoke</span><span class="token punctuation">(</span> std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span>T<span class="token punctuation">,</span> A0<span class="token operator">></span> lhs<span class="token punctuation">,</span> append_t<span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span>T<span class="token punctuation">,</span> A1<span class="token operator">></span> <span class="token keyword">const</span><span class="token operator">&</span> rhs <span class="token punctuation">)</span> <span class="token punctuation">{</span>
lhs<span class="token punctuation">.</span><span class="token function">insert</span><span class="token punctuation">(</span> lhs<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> rhs<span class="token punctuation">.</span><span class="token function">begin</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> rhs<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>lhs<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
<span class="token keyword">using</span> my_ns<span class="token double-colon punctuation">::</span>append<span class="token punctuation">;</span>
std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span><span class="token keyword">int</span><span class="token operator">></span> a <span class="token punctuation">{</span><span class="token number">1</span><span class="token punctuation">,</span><span class="token number">2</span><span class="token punctuation">,</span><span class="token number">3</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
std<span class="token double-colon punctuation">::</span>vector<span class="token operator"><</span><span class="token keyword">int</span><span class="token operator">></span> b <span class="token punctuation">{</span><span class="token number">4</span><span class="token punctuation">,</span><span class="token number">5</span><span class="token punctuation">,</span><span class="token number">6</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> c <span class="token operator">=</span> a <span class="token operator">*</span>append<span class="token operator">*</span> b<span class="token punctuation">;</span>
</code></pre></div><p>The core here is that we define an <code>append</code> object of type <code>append_t:named_operator::make_operator<append_t></code>.</p> <p>We then overload named_invoke( lhs, append_t, rhs ) for the types we want on the right and left.</p> <p>The library overloads <code>lhs*append_t</code>, returning a temporary <code>half_apply</code> object. It also overloads <code>half_apply*rhs</code> to call <code>named_invoke( lhs, append_t, rhs )</code>.</p> <p>We simply have to create the proper <code>append_t</code> token and do an ADL-friendly <code>named_invoke</code> of the proper signature, and everything hooks up and works.</p> <p>For a more complex example, suppose you want to have element-wise multiplication of elements of a std::array:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">class</span><span class="token operator">=</span><span class="token keyword">void</span><span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span>size_t<span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>Is<span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token function">indexer</span><span class="token punctuation">(</span> std<span class="token double-colon punctuation">::</span>index_sequence<span class="token operator"><</span>Is<span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token operator">></span> <span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">auto</span><span class="token operator">&&</span> f<span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token function">f</span><span class="token punctuation">(</span> std<span class="token double-colon punctuation">::</span>integral_constant<span class="token operator"><</span>std<span class="token double-colon punctuation">::</span>size_t<span class="token punctuation">,</span> Is<span class="token operator">></span><span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span> <span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token keyword">template</span><span class="token operator"><</span>std<span class="token double-colon punctuation">::</span>size_t N<span class="token operator">></span>
<span class="token keyword">auto</span> <span class="token function">indexer</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token keyword">return</span> <span class="token function">indexer</span><span class="token punctuation">(</span> std<span class="token double-colon punctuation">::</span>make_index_sequence<span class="token operator"><</span>N<span class="token operator">></span><span class="token punctuation">{</span><span class="token punctuation">}</span> <span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
<span class="token keyword">namespace</span> my_ns <span class="token punctuation">{</span>
<span class="token keyword">struct</span> <span class="token class-name">e_times_t</span> <span class="token operator">:</span> <span class="token base-clause">named_operator<span class="token double-colon punctuation">::</span><span class="token class-name">make_operator</span><span class="token operator"><</span><span class="token class-name">e_times_t</span><span class="token operator">></span></span> <span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">constexpr</span> e_times_t e_times<span class="token punctuation">{</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token keyword">template</span><span class="token operator"><</span><span class="token keyword">class</span> <span class="token class-name">L</span><span class="token punctuation">,</span> <span class="token keyword">class</span> <span class="token class-name">R</span><span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span>size_t N<span class="token punctuation">,</span>
<span class="token keyword">class</span> <span class="token class-name">Out</span><span class="token operator">=</span>std<span class="token double-colon punctuation">::</span>decay_t<span class="token operator"><</span><span class="token keyword">decltype</span><span class="token punctuation">(</span> std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">declval</span><span class="token generic class-name"><span class="token operator"><</span>L <span class="token keyword">const</span><span class="token operator">&</span><span class="token operator">></span></span></span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token operator">*</span>std<span class="token double-colon punctuation">::</span><span class="token generic-function"><span class="token function">declval</span><span class="token generic class-name"><span class="token operator"><</span>R <span class="token keyword">const</span><span class="token operator">&</span><span class="token operator">></span></span></span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">)</span><span class="token operator">></span>
<span class="token operator">></span>
std<span class="token double-colon punctuation">::</span>array<span class="token operator"><</span>Out<span class="token punctuation">,</span> N<span class="token operator">></span> <span class="token function">named_invoke</span><span class="token punctuation">(</span> std<span class="token double-colon punctuation">::</span>array<span class="token operator"><</span>L<span class="token punctuation">,</span> N<span class="token operator">></span> <span class="token keyword">const</span><span class="token operator">&</span> lhs<span class="token punctuation">,</span> e_times_t<span class="token punctuation">,</span> std<span class="token double-colon punctuation">::</span>array<span class="token operator"><</span>R<span class="token punctuation">,</span> N<span class="token operator">></span> <span class="token keyword">const</span><span class="token operator">&</span> rhs <span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">using</span> result_type <span class="token operator">=</span> std<span class="token double-colon punctuation">::</span>array<span class="token operator"><</span>Out<span class="token punctuation">,</span> N<span class="token operator">></span><span class="token punctuation">;</span>
<span class="token keyword">auto</span> index_over_N <span class="token operator">=</span> <span class="token generic-function"><span class="token function">indexer</span><span class="token generic class-name"><span class="token operator"><</span>N<span class="token operator">></span></span></span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> <span class="token function">index_over_N</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">auto</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>is<span class="token punctuation">)</span><span class="token operator">-></span>result_type <span class="token punctuation">{</span>
<span class="token keyword">return</span> <span class="token punctuation">{</span><span class="token punctuation">{</span>
<span class="token punctuation">(</span>lhs<span class="token punctuation">[</span>is<span class="token punctuation">]</span> <span class="token operator">*</span> rhs<span class="token punctuation">[</span>is<span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>
<span class="token punctuation">}</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span>
</code></pre></div><p><a href="http://coliru.stacked-crooked.com/a/c071a0662834c838" target="_blank" rel="noopener noreferrer">live example<span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></a>.</p> <p>This element-wise array code can be extended to work on tuples or pairs or C-style arrays, or even variable length containers if you decide what to do if the lengths don't match.</p> <p>You could also an element-wise operator type and get <code>lhs *element_wise<'+'>* rhs</code>.</p> <p>Writing a <code>*dot*</code> and <code>*cross*</code> product operators are also obvious uses.</p> <p>The use of <code>*</code> can be extended to support other delimiters, like <code>+</code>. The delimeter precidence determines the precidence of the named operator, which may be important when translating physics equations over to C++ with minimal use of extra <code>()</code>s.</p> <p>With a slight change in the library above, we can support <code>->*then*</code> operators and extend <code>std::function</code> prior to the standard being updated, or write monadic <code>->*bind*</code>. It could also have a stateful named operator, where we carefully pass the <code>Op</code> down to the final invoke function, permitting:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code>named_operator<span class="token operator"><</span><span class="token string">'*'</span><span class="token operator">></span> append <span class="token operator">=</span> <span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">auto</span> lhs<span class="token punctuation">,</span> <span class="token keyword">auto</span><span class="token operator">&&</span> rhs<span class="token punctuation">)</span> <span class="token punctuation">{</span>
<span class="token keyword">using</span> std<span class="token double-colon punctuation">::</span>begin<span class="token punctuation">;</span> <span class="token keyword">using</span> std<span class="token double-colon punctuation">::</span>end<span class="token punctuation">;</span>
lhs<span class="token punctuation">.</span><span class="token function">insert</span><span class="token punctuation">(</span> <span class="token function">end</span><span class="token punctuation">(</span>lhs<span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">begin</span><span class="token punctuation">(</span>rhs<span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">end</span><span class="token punctuation">(</span>rhs<span class="token punctuation">)</span> <span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> std<span class="token double-colon punctuation">::</span><span class="token function">move</span><span class="token punctuation">(</span>lhs<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
</code></pre></div><p>generating a named container-appending operator in C++17.</p> <h2 id="function-call-operator"><a href="#function-call-operator" class="header-anchor">#</a> Function call operator</h2> <p>You can overload the function call operator <code>()</code>:</p> <p>Overloading must be done inside of a <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//R -> Return type</span>
<span class="token comment">//Types -> any different type</span>
R <span class="token keyword">operator</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">(</span>Type name<span class="token punctuation">,</span> Type2 name2<span class="token punctuation">,</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">//Do something</span>
<span class="token comment">//return something</span>
<span class="token punctuation">}</span>
<span class="token comment">//Use it like this (R is return type, a and b are variables)</span>
R foo <span class="token operator">=</span> <span class="token function">object</span><span class="token punctuation">(</span>a<span class="token punctuation">,</span> b<span class="token punctuation">,</span> <span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre></div><p>For example:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token keyword">struct</span> <span class="token class-name">Sum</span>
<span class="token punctuation">{</span>
<span class="token keyword">int</span> <span class="token keyword">operator</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">(</span><span class="token keyword">int</span> a<span class="token punctuation">,</span> <span class="token keyword">int</span> b<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token keyword">return</span> a <span class="token operator">+</span> b<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token comment">//Create instance of struct</span>
Sum sum<span class="token punctuation">;</span>
<span class="token keyword">int</span> result <span class="token operator">=</span> <span class="token function">sum</span><span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">,</span> <span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token comment">//result == 2</span>
</code></pre></div><h2 id="bitwise-not-operator"><a href="#bitwise-not-operator" class="header-anchor">#</a> Bitwise NOT operator</h2> <p>Overloading the bitwise NOT (<code>~</code>) is fairly simple. <em>Scroll down for explanation</em></p> <p>Overloading outside of <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code>T <span class="token keyword">operator</span><span class="token operator">~</span><span class="token punctuation">(</span>T lhs<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
<span class="token comment">//Do operation</span>
<span class="token keyword">return</span> lhs<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><p>Overloading inside of <code>class</code>/<code>struct</code>:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code>T <span class="token keyword">operator</span><span class="token operator">~</span><span class="token punctuation">(</span><span class="token punctuation">)</span>
<span class="token punctuation">{</span>
T <span class="token function">t</span><span class="token punctuation">(</span><span class="token operator">*</span><span class="token keyword">this</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">//Do operation</span>
<span class="token keyword">return</span> t<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre></div><p>Note: <code>operator~</code> returns by value, because it has to return a new value (the modified value), and not a reference to the value (it would be a reference to the temporary object, which would have garbage value in it as soon as the operator is done). Not <code>const</code> either because the calling code should be able to modify it afterwards (i.e. <code>int a = ~a + 1;</code> should be possible).</p> <p>Inside the <code>class</code>/<code>struct</code> you have to make a temporary object, because you can't modify <code>this</code>, as it would modify the original object, which shouldn't be the case.</p> <h2 id="bit-shift-operators-for-i-o"><a href="#bit-shift-operators-for-i-o" class="header-anchor">#</a> Bit shift operators for I/O</h2> <p>The operators <code><<</code> and <code>>></code> are commonly used as "write" and "read" operators:</p> <ul><li><code>std::ostream</code> overloads <code><<</code> to write variables to the underlying stream (example: <code>std::cout</code>)</li> <li><code>std::istream</code> overloads <code>>></code> to read from the underlying stream to a variable (example: <code>std::cin</code>)</li></ul> <p>The way they do this is similar if you wanted to overload them "normally" outside of the <code>class</code>/<code>struct</code>, except that specifying the arguments are not of the same type:</p> <ul><li>Return type is the stream you want to overload from (for example, <code>std::ostream</code>) passed by reference, to allow chaining (Chaining: <code>std::cout << a << b;</code>). Example: <code>std::ostream&</code></li> <li><code>lhs</code> would be the same as the return type</li> <li><code>rhs</code> is the type you want to allow overloading from (i.e. <code>T</code>), passed by <code>const&</code> instead of value for performance reason (<code>rhs</code> shouldn't be changed anyway). Example: <code>const Vector&</code>.</li></ul> <p>Example:</p> <div class="language-cpp extra-class"><pre class="language-cpp"><code><span class="token comment">//Overload std::ostream operator<< to allow output from Vector's</span>
std<span class="token double-colon punctuation">::</span>ostream<span class="token operator">&</span> <span class="token keyword">operator</span><span class="token operator"><<</span><span class="token punctuation">(</span>std<span class="token double-colon punctuation">::</span>ostream<span class="token operator">&</span> lhs<span class="token punctuation">,</span> <span class="token keyword">const</span> Vector<span class="token operator">&</span> rhs<span class="token punctuation">)</span>
<span class="token punctuation">{</span>
lhs <span class="token operator"><<</span> <span class="token string">"x: "</span> <span class="token operator"><<</span> rhs<span class="token punctuation">.</span>x <span class="token operator"><<</span> <span class="token string">" y: "</span> <span class="token operator"><<</span> rhs<span class="token punctuation">.</span>y <span class="token operator"><<</span> <span class="token string">" z: "</span> <span class="token operator"><<</span> rhs<span class="token punctuation">.</span>z <span class="token operator"><<</span> <span class="token string">'\n'</span><span class="token punctuation">;</span>
<span class="token keyword">return</span> lhs<span class="token punctuation">;</span>
<span class="token punctuation">}</span>
Vector v <span class="token operator">=</span> <span class="token punctuation">{</span> <span class="token number">1</span><span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token comment">//Now you can do</span>
std<span class="token double-colon punctuation">::</span>cout <span class="token operator"><<</span> v<span class="token punctuation">;</span>
</code></pre></div><h4 id="remarks"><a href="#remarks" class="header-anchor">#</a> Remarks</h4> <p>The operators for built-in types cannot be changed, operators can only be overloaded for user-defined types. That is, at least one of the operands has to be of a user-defined type.</p> <p>The following operators <strong>cannot</strong> be overloaded:</p> <ul><li>The member access or "dot" operator <code>.</code></li> <li>The pointer to member access operator <code>.*</code></li> <li>The scope resolution operator, <code>::</code></li> <li>The ternary conditional operator, <code>?:</code></li> <li><code>dynamic_cast</code>, <code>static_cast</code>, <code>reinterpret_cast</code>, <code>const_cast</code>, <code>typeid</code>, <code>sizeof</code>, <code>alignof</code>, and <code>noexcept</code></li> <li>The preprocessing directives, <code>#</code> and <code>##</code>, which are executed before any type information is available.</li></ul> <p>There are some operators that you should <strong>not</strong> (99.98% of the time) overload:</p> <ul><li><code>&&</code> and <code>||</code> (prefer, instead, to use implicit conversion to <code>bool</code>)</li> <li><code>,</code></li> <li>The address-of operator (unary <code>&</code>)</li></ul> <p>Why? Because they overload operators that another programmer might never expect, resulting in different behavior than anticipated.</p> <p>For example, the user defined <code>&&</code> and <code>||</code> overloads of these operators <a href="http://en.cppreference.com/w/cpp/language/operators#Restrictions" target="_blank" rel="noopener noreferrer">lose their short-circuit evaluation<span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></a> and <a href="http://en.cppreference.com/w/cpp/language/operators#Restrictions" target="_blank" rel="noopener noreferrer">lose their special sequencing properties (C++17)<span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></a>, the sequencing issue also applies to <code>,</code> operator overloads.</p></div> <footer class="page-edit"><div class="edit-link"><a href="https://github.com/devtut/generate/edit/master/docs/cpp/operator-overloading.md" target="_blank" rel="noopener noreferrer">Edit this page on GitHub</a> <span><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" focusable="false" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg> <span class="sr-only">(opens new window)</span></span></div> <!----></footer> <div class="page-nav"><p class="inner"><span class="prev">
←
<a href="/cpp/function-overloading.html" class="prev">
Function Overloading
</a></span> <span class="next"><a href="/cpp/function-template-overloading.html">
Function Template Overloading
</a>
→
</span></p></div> </main></div><div class="global-ui"><!----></div></div>
<script src="/assets/js/app.1779e102.js" defer></script><script src="/assets/js/3.2cfa8016.js" defer></script><script src="/assets/js/683.89317374.js" defer></script>
</body>
</html>