.. okay got it

Long long int

Thanx I'll look into it

long long = long long int

oh really

long long unsigned int

N1570 7.21.5.2 states flushing an Inputstream is undefined behavior

Someone should really write a compiler generating code that terminates once undefined behavior is invoked

Someone should really write a compiler generating code that terminates once undefined behavior is invoked

It throws a warning

It throws a warning

But most will argue "it still works". With such a compiler you could proof it not working

But most will argue "it still works". With such a compiler you could proof it not working

Lol, what you as is to make a "treat warnings as mistakes" flag by default :D

Lol, what you as is to make a "treat warnings as mistakes" flag by default :D

No, not being C++98 compatible may warn as well, nothing wrong with it. I want your executable to terminated once undefined behavior is invoked. The compiler is perfectly allowed to do this.

No, not being C++98 compatible may warn as well, nothing wrong with it. I want your executable to terminated once undefined behavior is invoked. The compiler is perfectly allowed to do this.

It's a whole bunch code, that must work at runtime :D

It's a whole bunch code, that must work at runtime :D

What must work at runtime?

Parameter passed to main, parameters you start your executable with

What must work at runtime?

You want to monitor your executable during it's runtime.

You want to monitor your executable during it's runtime.

No

By the way, clang specifically writes it if you have a UB

#include <iostream> int main() { int a = 5; a = a++; std::cout << a << std::endl; return 0; } Well, GCC writes: source_file.cpp:8:12: warning: operation on ‘a’ may be undefined [-Wsequence-point] a = a++;

No

If you find a UB at compile time, you don't even have to generate an executable~

By the way, clang specifically writes it if you have a UB

Does not always work unfortunately

It is always undefined

I also think anyone should work with a treat warnings as error flags. If you have to compile with a warning, you have to disable it

Why do you start each line with an uppercase?

Why do you start each line with an uppercase?

Probably is a phone

That code will not compile otherwise

fflush makes no difference on my system

Since undefined behavior

No my compiler can do what it wants in this case. Your code is not valid c.

Use a space before %c, this will discard whitespace characters

Printf("dya wanna try again (y/n); You have to close a quote make, btw~

I know I'm annoying

From w-what? :c

I see it's no Java, what do you mean by mother array?

Well, cout does'nt print arrays. You can do it in a loop

#include <iostream> int main() { long array[2][2] = {{2, 3}, {4, 6}}; for(int i : array[1]) std::cout << i << " "; std::cout << std::endl; return 0; } Only like this~

Prefer std::array over c style arrays in c++

The parenthesis are optional And no it's a range for loop

Isn't it great? :D

You know, there is a fun way to print an array otherwhise

But don't laugh 😂

https://lemire.me/blog/2018/09/07/avx-512-when-and-how-to-use-these-new-instructions/

#include <iostream> #include <iterator> int main() { int lol[] {2, 3, 5, 7, 8}; std::copy(std::begin(lol), std::end(lol), std::ostream_iterator<int>(std::cout, " ")); return 0; }

Ah, it's not that hard

It'll work #include <iostream> #include <iterator> int main() { int lol[2][3] {{2, 3, 5}, {7, 8, 5}}; std::copy(std::begin(lol[1]), std::end(lol[1]), std::ostream_iterator<int>(std::cout, " ")); return 0; }

prints 7 8 5, lol

You can also write std::begin(lol[0], std::end(lol[1]) and it'll print the whole thing :D

lol basics 5th grade

This was just fooling around, lol

And you definitely should not use C-like arrays in this fashion

lol basics 5th grade

Thanks for ruining my day btw

Thanks for ruining my day btw

nah I am just kidding

you get A+

In the 5th grade I would ^_^

Prefer std::array over c style arrays in c++

.

Prefer std::array over c style arrays in c++

plus plus

plus plus

:)

And v...vectors~

And v...vectors~

only for dynamic arays

vectors are slower than arrays

std::stack

But do note std::arrays use no dynamic memory allocation

only for dynamic arays

Well, I mean... C-arrays can be both static and dynamic. And you should use std::arrays and vectors instead.

Well, I mean... C-arrays can be both static and dynamic. And you should use std::arrays and vectors instead.

c arrays are static

c arrays are static

you have to reallocate and copy them in order to simulate a dynamicity (which is what vector wraps)

c arrays are static

Ah... realloc anyone? :D

Dynamic is in terms of resizing, you cannot resize neither a std::array nor a c style array

Ah... realloc anyone? :D

std::vector actually just re-allocates instead of changing the vector size

std::vector actually just re-allocates instead of changing the vector size

Atleast in CLINL, as long as there is no realloc

Ah... realloc anyone? :D

Does not change the array size but changes the array

std::vector actually just re-allocates instead of changing the vector size

I know. C code uses reallocation a lot

Cause you need a dynamic array in your life

Cause you need a dynamic array in your life

And you still think that C is better for a beginner to learn?

Does not change the array size but changes the array

C-style array can be allocated with a new(malloc) It makes it dynamic, cause its size is not known to the compiller

C-style array can be allocated with a new(malloc) It makes it dynamic, cause its size is not known to the compiller

C-Style arrays are the things that look like this: int a [size]; actually in C you can use a variable as size index

C-Style arrays are the things that look like this: int a [size]; actually in C you can use a variable as size index

That'll not compile on a windows compiller :D

int size = 10; int a [size];

should compile on a C11 compiler

You CANNOT change the size of a C-array. you can only reallocate it

C-style array can be allocated with a new(malloc) It makes it dynamic, cause its size is not known to the compiller

Obviously. But realloc is reallocating.