He realized he confused whether the like button was on the right or the left only to realize that in video format he's is in the mirror anyways.

It is a major speed boost

Hristo Hristov nice example of implicit constructors : en.cppreference.com/w/cpp/language/converting_constructor

its because of the conversion constructor (one which takes only one parameter)

destructed :)

It went out of scope

The memory holding it was freed. It is now swimming in a salt lake in turkey. That beautiful log

+John Doe Cooking with Cherno (TM) is coming soon ;)

I'd actually watch that.

@@TheCherno Cooking with Charno (No offense intended)

Of course there is ;) Take a look at the c++ 11 header. It allows you to measure time up to nanosecond precision.

Jesus...the amount of libraries for C++ is over 9000. Thanks dude!

ITS OVER 9000!

Are you asking if constructors can have parameters? If so, then the answer is no.

Yea, just wanted to know that, thanks =)

@Or Aviram, I'm just gonna clarify your comment and clear up any confusion for anyone reading it. I think you meant to say destructors can't have parameters. Probably just a typo, but yeh constructors can have parameters.

Yeah, that's what I meant. :P

Ram is physical memory in a computer. If you have a computer program running on a PC with operating system, the OS hides all interractions between the RAM and the program with virtual memory. I.E program is only aware of the virtual memory that the OS provides. Then what is stack? It is a section of that virtual memory that the program uses to handle static memory allocations. static means that the size is known when the code is compiled to an executable. Heap is part of the virtual memory where the program can make dynamic memory allocations. Dynamic means that the needed memory size is known when the executable is running. Cache is a term used when you have two programs running at the same time: server and client. And the client asks server to perform some operation for example calculate what is 2+2 and return the result back. When client gets the result 4 it can assume that the result will also be 4 next time so it can cache the ressult to a variable and next time the user of the client program needs to calculate 2+2 the client can return the cached answer instead of asking the server again. So all in all they dont really relate at all.

new hair series

Hair++ Im in

1. static in a functions means that every times you call this function this array will be the same. 2. Your code is not valid. You could write this code: int* create_array() { static int result[50]; return result; } but every time you use this function you get the same array. Look at this code: int * a = create_array(); int * b = create_array(); a[0] = 5; b[1] = 10; std::cout

Anyone who said that he teaches bad , should recheck their scope

@Peterolen you're right, that's a good point

First of all you have to include "memory" to your app. Next step is access it in std namespace. #include #include int main(int argc, char** argv){ std::unique_ptr name = std::make_unique(10); //or std::unique_ptr name2 (new int(10)); return 0; }

First, the internet exists, google it, you would get the answer much faster. Second, #include std::unique_ptr ptr;

Don't trust the cherno. Trust the community

unique ptr gets destroyed out of scope but the object that the ptr is pointing to is not destroyed when you allocate objects on the stack, you can only pass objects into functions via copy, and not reference, which might not be performant for big objects sometimes you may also want the object to outlive the lexical scope where it has been declared, in which case you would use a pointer like unique ptr

So order for an object to be in the stack, its size should be known at compile time (some compilers have extensions but its not in the c++ standard). More often than not, you'd have unique_ptr members in classes than functions returning a unique_ptr. Data that are loaded in and/or change during runtime usually would have its resources allocated in the heap. You probably want such data get automatically freed when it goes out of scope so no memory is being leaked. E.g. Resources like image and audio, containers, data structures, are all good candidates for having a unique_ptr to the raw allocated memory so it gets automatically freed when the encapsulating object is destroyed.

Or that the moment I assign stack address to a pointer It become heap allocated and not deallocate automatically?

Will fast typing need relax and patience

When an array is "deleted", the memory where it was stored is not actually immediately used for something else. It is simply marked as "free" to be used when necessary. So if you check memory right after it is deleted, it is still there, but it might be overwritten at any time with new data (this is true for space allocated both in the stack and in the heap). In fact, it is a typical bug to use memory that has already been deleted without noticing, and the program works fine for a while until you change something that seems completely unrelated and that suddenly breaks all kind of things. These are notoriously hard to fix.

@@nmamano Thanks BRO! :D

ScopedPtr has a constructor which accepts Entity* as an argument, and the constructor is smart enough to do an implicit cast here. That code has equal behaviour to ScopedPtr e(new Entity());

Problem here is that we are returning an address which may not exist in memory after function call/scope is over. Although it gives the output, it is considered as bad practice(?) and may result in further problems down the line when allocating memory in stack. I am a mostly beginner myself so i hope someone more adept can jump in and say if i am wrong. ngl i also find it extremely weird that it still outputted a value and not a garbage one.

@@flamez5493 By a garbage one, do you mean the second value? If so, it is because the output is not an array but a single value (a[4]).

It have to be in different locations depends in your language

You can watch the video on String Literals and constant memory (video 33 in the playlist)

@@KostasOreopoulos Thank you

Reason is: char* name = (char*) "Leonsius"; // this is String literal and it's storage in const data segment. the same reason without cast it's necessary const key word