Can I get easy understanding c++ pdf

Hello, i have question. Which is one is effective ? type arr[x] = {0}; or type arr[x]; memset(arr, 0, sizeof(arr));

memset one, but that all is unsafe in some terms

Hello, i have question. Which is one is effective ? type arr[x] = {0}; or type arr[x]; memset(arr, 0, sizeof(arr));

Hello, i have question. Which is one is effective ? type arr[x] = {0}; or type arr[x]; memset(arr, 0, sizeof(arr));

Every part😁

This code will never be a problem in terms of performance

Okay, silly me. it must be sizeof(arr) not sizeof(x).

Just curious, what version of CPP is that? I just try to compile both and I can't.

Hello. I'm so sorry. I know that this group is for C and Cpp but maybe someone know Assembler NASM x86?

Hello, i have question. Which is one is effective ? type arr[x] = {0}; or type arr[x]; memset(arr, 0, sizeof(arr));

Somebody has the link to the so called OT group…?

Ok, I made this into real C++ code and managed to compile. When you asked this quesiton the first thing that came to my mind is "the answer depends on what the compiler will do with this code". The answer for the GCC compiler is: 1) Without optimization the first option is more efficient as the second option will call a function, and more operations will have to be performed. 2) With full optimization "-O3", both options will produce *identical* binaries.

Why when scanning an integer you have to give the address?

Why when scanning an integer you have to give the address?

But you don't need an address to scan other data types, right?

So the outside function is scanf here?

Can i define a macro by setting its value equal to a function? Something like: #ifndef INT_MIN #define INT_MIN std::numeric_limits<int>::min() #endif

The macro will be replaced literally as like you are calling that said function INT_MIN would not be fixed, but it's value would be std::numeric_limits<int>::min()

Ok, I made this into real C++ code and managed to compile. When you asked this quesiton the first thing that came to my mind is "the answer depends on what the compiler will do with this code". The answer for the GCC compiler is: 1) Without optimization the first option is more efficient as the second option will call a function, and more operations will have to be performed. 2) With full optimization "-O3", both options will produce *identical* binaries.

Danya already provided the answer to this question. As far as your reply is concerned, the first case is not correct. How do you think the compiler initializes memory? Both the options will be equally good as far as speed is concerned and the second option will not work for non trivial types (non POD types) as already pointed out

That's the thing, I don't need to "think" how the compiler initializes the memory. I can just ask, and I will know for a fact. In order to compile the code, I supposed the type was a char[16]. In this case, GCC will do exactly the same thing for any of the following pieces of code: 1) char x[16] = {0}; 2) char x[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 3) char x[16]; memset(x, 0, sizeof(char[16])); And this is how GCC tells me it will do: xorl %eax, %eax The funny thing is why does it write that assembly instead of this: mov eax,0x0 Apparently, the xor code is faster than the mov one, and that's what GCC will do when you use the -O3 switch.

Which is exactly what happens in both the cases the OP suggested. So your saying that calling memset will be slower without the optimization flag is not correct.

Without the optimization flag there will be a function call for memset. That is extra operations and those aren't free. Without optimization the memset option will necessarily be less efficient.

I just tried compiling the code with -O1 , -O2 and -O3 on both Clang and gcc. The compiler is smart enough to allocate storage for the array in a register in all the 3 cases.

I'm not saying that the compiler is not smart. I am just saying that GCC without optimization (-O1 is optimization) will write code that represents more operations, namely the call for the function memset, than in the other situations. And again, I'm not supposing anything. I'm talking about the actual assembly output. Here is my command line: g++ main.cpp -S You can try it yourself, and then diff the files and you'll see that the difference is the function call.

I just did. In the example case that you suggested i.e char [16], the compiler easily figured out that it can be stored in an array. For a larger array which can't fit into a register (for example I did a atomic RMW operation to force memory allocation), the compiler has the same behavior for both braced initialization and memset. This is because the compiler inserts a call to memset for the braced initialization case anyway. So the performance is the same

How to take unknown number of input from user. If we want to get input in array or vector we ask "n" to create n size array. How to get input without n

What do you want to do with programming for Win32 or higher level systems?

It doesn't work like this, OOP is a huge topic that has articles, videos and even books about it all around internet. And instead of learning using these materials you want someone to repeat this information to you? :)

During which phase templates are processed ?

At compile-time ( but it depends on the implementation )

Anybody, how does opening a new tab works technically

You can read chromium source code and figure out it yourself

yes i have chromium already, i should have framed the question to point to frontend, generally what am asking for is how this works on the frontend e.g if you are to use chromium as the engine and you are building your own frontend

What do you mean by frontend? A web app?

For-example as a frontend dev e.g for chrome, what kind of steps you would take to open a new tab

And why do you ask it here? In C++ chat?

Have you even tried googling?

Good day. Maybe someone knows. How it is possible to implement such addition in an array[1,2,3,4]like first 0 seconds 1... 3-t is 1+2..... Output [0,1, 3,6] . I will be grateful

Like 0 1 1+2 1+2+3 Output[0,1,3,6]

That's the thing, I don't need to "think" how the compiler initializes the memory. I can just ask, and I will know for a fact. In order to compile the code, I supposed the type was a char[16]. In this case, GCC will do exactly the same thing for any of the following pieces of code: 1) char x[16] = {0}; 2) char x[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 3) char x[16]; memset(x, 0, sizeof(char[16])); And this is how GCC tells me it will do: xorl %eax, %eax The funny thing is why does it write that assembly instead of this: mov eax,0x0 Apparently, the xor code is faster than the mov one, and that's what GCC will do when you use the -O3 switch.

Pre-mature optimizations again.. Aren't you tired of it?

yeah I know, Idk why the heck I'm paranoid of performance

But just giving compiler the job for optimization is clearly stupid even with -O3 . since different compiler doesn't guarantee give same output with another compiler.

What do you want to do with programming for Win32 or higher level systems?