# iomanip

***

**1. Formatting Integer Output**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 12345;
  cout << setw(10) << num; // Output:  12345
  return 0;
}
```

**2. Left-Justifying String Output**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  string str = "Hello";
  cout << setw(10) << left << str; // Output: Hello
  return 0;
}
```

**3. Right-Justifying String Output**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  string str = "Hello";
  cout << setw(10) << right << str; // Output:    Hello
  return 0;
}
```

**4. Centering String Output**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  string str = "Hello";
  cout << setw(10) << center << str; // Output:  Hello 
  return 0;
}
```

**5. Setting Field Width**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 12345;
  cout << setw(10) << num; // Output:  12345
  return 0;
}
```

**6. Truncating Output**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  string str = "Hello World";
  cout << setw(10) << str; // Output: Hello Wor (truncated)
  return 0;
}
```

**7. Inserting Leading Zeros**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << setfill('0') << num; // Output: 000000123
  return 0;
}
```

**8. Inserting Leading Spaces**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << setfill(' ') << num; // Output:       123
  return 0;
}
```

**9. Formatting Floating-Point Numbers**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 3.14159;
  cout << fixed << setprecision(2) << num; // Output: 3.14
  return 0;
}
```

**10. Suppressing Scientific Notation**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 1.23456789e+10;
  cout << fixed << setprecision(2) << num; // Output: 12345678900.00
  return 0;
}
```

**11. Formatting Boolean Values**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  bool b = true;
  cout << boolalpha << b; // Output: true
  return 0;
}
```

**12. Formatting Hexadecimal Values**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << hex << num; // Output: 7b
  return 0;
}
```

**13. Formatting Octal Values**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << oct << num; // Output: 173
  return 0;
}
```

**14. Formatting Money**

```cpp
#include <iostream>
#include <iomanip>
#include <locale>

using namespace std;

int main() {
  double money = 1234.56;
  cout.imbue(locale("")); // Set locale to current locale
  cout << fixed << setprecision(2) << showpoint << money; // Output: $1,234.56
  return 0;
}
```

**15. Formatting Dates**

```cpp
#include <iostream>
#include <iomanip>
#include <ctime>

using namespace std;

int main() {
  time_t t = time(0);
  tm *now = localtime(&t);
  cout << put_time(now, "%c"); // Output: Wed Jun 30 23:59:59 2021
  return 0;
}
```

**16. Formatting Characters**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  char c = 'A';
  cout << setw(10) << left << c; // Output:  A
  return 0;
}
```

**17. Formatting Pointers**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int *p = nullptr;
  cout << setw(10) << left << p; // Output:     0x0
  return 0;
}
```

**18. Formatting User-Defined Types (struct)**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

struct Point {
  int x;
  int y;
};

ostream& operator<<(ostream& os, const Point& p) {
  os << "(" << p.x << ", " << p.y << ")";
  return os;
}

int main() {
  Point p{1, 2};
  cout << setw(10) << left << p; // Output:  (1, 2)
  return 0;
}
```

**19. Formatting User-Defined Types (class)**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

class Point {
public:
  int x;
  int y;

  friend ostream& operator<<(ostream& os, const Point& p) {
    os << "(" << p.x << ", " << p.y << ")";
    return os;
  }
};

int main() {
  Point p{1, 2};
  cout << setw(10) << left << p; // Output:  (1, 2)
  return 0;
}
```

**20. Avoiding Left-Padding**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << right << noshowpos << num; // Output:    123
  return 0;
}
```

**21. Suppressing Leading Zeros for Float**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 0.000123;
  cout << fixed << setprecision(3) << num; // Output: 0.000
  return 0;
}
```

**22. Using showpoint for Float**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 0.000123;
  cout << fixed << setprecision(3) << showpoint << num; // Output: 0.000
  return 0;
}
```

**23. Aligning Characters**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  char c = 'A';
  cout << setw(10) << internal << c; // Output:      A
  return 0;
}
```

**24. Using Copy Delimiter**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 12345;
  cout << setfill('*') << setw(10) << internal << num; // Output: ****12345
  return 0;
}
```

**25. Suppressing Trailing Zeros**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 123.000;
  cout << fixed << setprecision(3) << nozero << num; // Output: 123
  return 0;
}
```

**26. Using setbase**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setbase(16) << num; // Output: 7b
  return 0;
}
```

**27. Using setfill**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setfill('*') << setw(10) << num; // Output: ****123
  return 0;
}
```

**28. Using left**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << left << num; // Output:  123
  return 0;
}
```

**29. Using noshowpos**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << right << noshowpos << num; // Output:    123
  return 0;
}
```

**30. Using right**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << right << num; // Output:    123
  return 0;
}
```

**31. Using scientific**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 123.456;
  cout << scientific << num; // Output: 1.234560e+02
  return 0;
}
```

**32. Using setprecision**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 123.456;
  cout << fixed << setprecision(2) << num; // Output: 123.45
  return 0;
}
```

**33. Using showpoint**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 0.000123;
  cout << fixed << setprecision(3) << showpoint << num; // Output: 0.000
  return 0;
}
```

**34. Using uppercase**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << uppercase << hex << num; // Output: 7B
  return 0;
}
```

**35. Using ws**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 123.456;
  cout << ws << num; // Output: 123.456
  return 0;
}
```

**36. Using oct**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << oct << num; // Output: 173
  return 0;
}
```

**37. Using hex**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << hex << num; // Output: 7b
  return 0;
}
```

**38. Using fixed**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 123.456;
  cout << fixed << num; // Output: 123
  return 0;
}
```

**39. Using boolalpha**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  bool b = true;
  cout << boolalpha << b; // Output: true
  return 0;
}
```

**40. Using flush**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  cout << "Hello" << flush; // Output: Hello
  return 0;
}
```

**41. Using dec**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << dec << num; // Output: 123
  return 0;
}
```

**42. Using copyfmt**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setiosflags(ios::dec) << num; // Output: 123
  return 0;
}
```

**43. Using setbase**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setbase(8) << num; // Output: 173
  return 0;
}
```

**44. Using setw**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << num; // Output:  123
  return 0;
}
```

**45. Using internal**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << internal << num; // Output:      123
  return 0;
}
```

**46. Using showpos**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setw(10) << right << showpos << num; // Output:    +123
  return 0;
}
```

**47. Using setfill**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << setfill('*') << setw(10) << num; // Output: ****123
  return 0;
}
```

**48. Using setprecision**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 123.456;
  cout << fixed << setprecision(2) << num; // Output: 123.45
  return 0;
}
```

**49. Using uppercase**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  int num = 123;
  cout << uppercase << hex << num; // Output: 7B
  return 0;
}
```

**50. Using ws**

```cpp
#include <iostream>
#include <iomanip>

using namespace std;

int main() {
  double num = 123.456;
  cout << ws << num; // Output: 123.456
  return 0;
}
```