I know it's quite funny, maybe little annoying but really, he can't cover everything in one video. We should be thankful for him even making those videos for free, for us. Hope you guys understand him.
@@geiger21 Yeah it ain't no big deal to me man, I completely get it. Can't speak for others of course. I just thought it was funny and figured I would make light of it is all.
I know right! It is comical and want to give him hell but I know how complicated this is and impossible to cover in a few minutes. I have to say he has covered quite a lot
that was big problem for me when I tried OpenGL. So I gave it a try in C. The difference is huge. I no longer need to decide whether to use std::vector, regular array, something else, I just need to use malloc and then eventually realloc. I like that simplicity.
@@Dhruvpatel-gb4pv I'm surprised, but it works. I just guess the compiler treats it as a kind of template. As long as you don't call it in the code, it doesn't check if the argument has a size function. Or if it provides [] operator. If you pass something that, when substituted for auto is not valid you just get a compiler error. I've just checked it - it behaves exactly like a template. I tried to create a header file and definition file containing a function with auto argument - it works only when it's defined in the header. So - you can use a proper template instead, or just leave auto. Compiler doesn't seem to care, however VS autocomplete prefers a template over auto.
It's worth noting that the size() function is also constexpr, so it doesn't actually return 5, but rather the compiler will just replace the function call itself with 5, so something like: int s = ary.size(); literally becomes int s = 5; with no function call at runtime.
@@toao_rainyssorry for the delayed response. I didn't get a notification for this comment. inline means "please copy this code body into the places that call it instead of having it be an actual function call" and constexpr means "please calculate this out at compile time instead of figuring it out at runtime". This is strongly preferred to declaring constants with #define, etc. These days you don't really need to tell the compiler to inline, as it will do so when appropriate, and if it's not appropriate then it will ignore the directive even if you use it.
I think there is one crucial thing to note: Bounds checking with std::array [] operator is not guaranteed in debug mode. If anyone wants to make sure that they have bounds checking, they should use the .at() instead of the [] operator to access array elements since bounds checking with .at() method is required by c++ standard, but it is not the case for the [] operator. Bounds checking is always enabled with .at() method, regardless of the build type of your program, meaning it's built into the program even when compiling in release mode with compiler optimization. For MSVC, as @cherno has shown, the [] operator supports bounds checking and disables it during release builds. But for the compiler I am using, which is GCC, bounds checking is completely none-existent with [] operator. Anyways, thanks for your awesome videos. I have learned a lot from your content and your videos are with all seriousness life-changing to me.
Imankalyan maity To improve on this, you could just use N in your for loop instead of arr.size(). This way, you do not incur any runtime cost of evaluating the size() function and instead just use an int literal.
As most of the guys here have guessed, the correct way to print an std::array is to use a template function. Hohewer, I need to show off, so here's a function to print any iterable collection passing its begin() and end() . template void printCollection(Iterator first, Iterator last) { for (auto it = first; it < last; ++it) { std::cout
@@VarunSingh000 I don't know Python much, but this reminds me of C#'s methods for working with any IEmumerable collections. It's better than C++ STL way like in my example, as from the outside you just pass a collection itself, not these two separate "begin" and "end" things. And this collection later provides means to iterate over itself, but this happens INSIDE of a method. So iterators are hidden, as all implementation details should be. Python is a beautuful language, by the way. I just prefer typed languages
I think the best solution to the array size function parameter function is to make use of auto declarations as function arguments from C++20. The below compiles perfectly (tested on gcc): #include #include void PrintArray(const auto& data) { std::cout
@@germanassasin1046This is mostly untrue. If/else statements are nearly ALWAYS more performant if written branchless. The branch prediction will do most of the heavy lifting, but an if/else nearly always ends up as a test/je/jnz. In the above example the predictor is only "warming up" on such a small array so branchless will out perform if/else. On a larger array, well, now you start to get a win/break-even with branchless because the condition only occurs at the end of the array. But start to use variable sized arrays and branchless will always will however good your optimizing compiler is. The downside to branchless is really the complexity and understandable logic.
I dislike this C++20 feature badly. Now you completely obscure what the incoming argument type is. It's one stage away from writing ... auto i = 0 and use auto everywhere.
Great!! so sensible. I would like to add two point, hope you will be aligned with me. 1. Usage of static_assert and assert Functions with std::array: static_assert and other assertion functions work effectively with std::array because its result is a compile-time constant, and conditions are evaluated at compile time. Since std::array has a fixed size known at compile time, it is suitable for use in compile-time checks like static_assert. 2. Applicability of constexpr with std::array and std::vector: constexpr can be effectively used with std::array as it is resolved at compile time and its size is known at compile time. On the other hand, std::vector is a runtime container, and its size is determined at runtime. Therefore, it is not suitable for use in constexpr contexts.
using gsl::span of the Guidelines Support Library (is a Microsoft implementation of some of the types and functions described in the C++ Core Guidelines)
@@pedrocalorio1655 It reffers than you don't depend on the IDE+OS to have a proper portable project. Due to Make is cross platform, and some IDEs are too (like VSCode), you can set up an environment of c++, make and visual studio code in any OS.
4:03 I was randomly trying stuff, and the one that executed without compile time error was to make the printArray() function a template with size and types as parameters like so: template printArray(const std::array &array) {}
For regular arrays, you can increase its size by one and add one special character at the end of it. Inside printArray() just loop until you hit special character and voila you have the correct size. You must use the type of the array element to calculate the correct size. Its not very fast I think but it works.
awesome series. you should edit out the "challenges". not many watches youtube guides to be told to google or find another vid explaining the details of the vid you are watching to learn the details ;) but awesome c++ series ^^
Solution to pass the size as param when using STL Array. Pass the size as a template. Example template void PrintArray(std::array& data) { /* do something* / }
I think that if you don't know the size, you can either use a template or a macro but I think you have explicitly said that macros are mostly bad except for debugging and too much templating can become dubious. Based on my current knowledge I would probably use a template.
You could write it using a template: This has the drawbacks of longer compile time (not that noticeable) and the exe file would be slightly larger because every different variant of that function needs to be created and compiled. Right? template void PrintArray(const std::array& data)
You can get the size of an array by dividing the total size by the size of one element which works cuz its contiguous memory: int size = sizeof(arr)/sizeof(arr[0])
Iterator mimics pointer arithmetic, so std::array iterators are not an advantage over usual c++ array, but a way to get closer in functionality to the usual c++ array. All standard algorithms, like sort(), work on bare c++ arrays: int a[] = {3, 2, 1}; sort(a, a + 3); // it works
something strange is happening here.. when i turn on subtitles it only allows russian, when i change it to auto gen russian to >>English, the only subtitle that comes up is "high five i have beyonce and funding"+"intensive and accessories and frill"+ "new style extract"+"whats the trouble"+ "he contracted st"+"bad girl i like slow mo guys"
Isn't adding too many std::array with varying sizes (say for the same data type) will increase the size of program memory (code segment)? The size stored as a literal in the compiled program and that template is for every size type at the cost of program size.
I attempted the challenge using a template function and extra feature for type of the array too: template void printArray(const std::array& arr) { for(dataType& value : arr) { std::cout
My Solution: template // cant use int instead of size_t because the size of container(std::array) is in *size_t* void printData(std::array& data1) { for(auto val : data1) std::cout
my version of the answer to the question is: what if I recreate it whenever I use or change it every time, like a static variable. creating a new pointer and pointing to the new pointer then removing an array old version.
Just gonna mention that the size is almost impossible to determain for a pointer, there are tricks but they are definitivly not guaranteed to reveal the size. That's why you always write: (int argc, char** argv). The argv is just an array of string, but the size is unknown, so argc is passed as the size for argv.
And yeah, it's not necessary to pass the template argument to a template function, because the compiler calculates it itself at the compile time. However, you have to pass template arguments, when you create an object of a template class. So, the function call like this - func(testing) - will work just fine.
When can we expect a video on namespaces? They seem like such a powerful tool especially when wanting to optionally include libraries. I am sure there are many other uses beyond just code structure. Other topic I would like to see is the exploration of extern "C" to prevent name mangling. Why is this used so much? What benefits/drawbacks does it provide. Thanks for the vids. Been a good supplement to my learning by providing good context to concepts.
Not sure if you still have this problem 4 years later, but he has a dedicated video in the learning C++ series that you should take a look at. Coming from C# namespaces used to confuse me in C++
You're not right. You can use standard algorithms with C-style array. For begin iterator you use a name of an array and for the end one - name + size. To use differently sized std::array's in one function you need to make this function a template one like this: template void func(const std::array arr); But you can use it for C-style arrays either: template void func(int arr[size]); But yeah, the debugging layout is useful
My solution looks like something like this: (in this case its always ints, but you could do a typename version too) template void PrintArraySize(const std::array& data) { for (size_t i = 0; i < data.size(); i++) { std::cout
For a version that takes any type we could write: template void PrintArraySize(const std::array& data) { for (size_t i = 0; i < data.size(); i++) { std::cout
I realise this video is 10 months old, but I wanted to point out you can just use the auto keyword, no template needed: void PrintArray(const auto& data) { for (int i = 0; i < data.size(); i++) { cout
Cherno, bruh, correct me if I'm wrong but isn't returning 5 actaully means the function stores this constant internally as an int? So yeah, it is not a variable in the sense that you can not change its value, but still, it must store this value somewhere. (Perhaps as a 'const int'.) I mean, what does a compiler do when it encounters a constant like 5 through code? Doesn't it store it somewhere? Thanks for all the effort you're taking to share with us. This channel is awesome! And fix that AC! ;)
It is just CPU instruction, so its hard-coded in your binary file. It wont be stored in memory at all. compiler gives you just assembly code, something like: add ax, 42 (add 42 (2E) to accumulator) which looks in binary file like this (HEX): 05 2A 00
You can pass the address of std::array as void* ptr in function argument and by knowning the offset of size inside array class you can find it like this: int size = *(int*)(uintptr_t(ptr) + *size_offset*)
@@ДмитроПрищепа-д3яYou could do this, but the problem is that you're relying on the internal structure of the array object. Now whilst this might work, if you used a different compiler that lays out the object structure differently, it'll break badly. I'm not objecting completely because using a pointer is easily the most efficient way of passing the array object. The problem really is that inside the function, you have to cast it back and as a void pointer, you don't know its actual type. A template is a good idea, but it's only really the same as having a function take an array and size argument.
How do writing template void PrintArray(const std::array& data) {...} and then PrintArray(data); will work ? I thought it should be wrote like that: PrintArray(data); Sorry if my english is bad I am french
Class template argument deduction (CTAD) (since C++17): As Zhuolin Fu said, in THIS case the compiler is going to deduce the template argument from the type of "data".
Challenge accepted: Use for each or just calculate size of the array. I'm I stupid and I'm not understanding something or what? Void printArray( int* arr) { for (auto i: arr) serial.println(i); // or For (int I = 0; I < sizeof(arr) / sizeof(int); i++) //Int is default cuz this is parameter type, u can make template out of it }
Passing as a const int for the size as const int size = 5; void print_std_array(std::array my_array) { for (size_t i = 0; i < my_array.size(); i++) { std::cout
I do have questions about performances: 1/ Imagine you want to create 1000 array with differents size. Because of the template behavior, wouldn't it copy theses 500 lines of code every time and makes your executable much much larger ? 2/ When you do data.size() in the for loop, because it is not an "inline" function doesn't it makes a function call every time it reaches data.size(), making your code slower ? Same question with the operator[] which is a not inline function Thank you for thoses who will answer me and sorry for my bad english, I am french and I try to improve myself.
So i figured i could use void PrintArray(auto array) { ... } to print any array. However... I'm not sure why, but this seems to have problems as my IDE marks it as error and my compiler yells at me for using it even so the code compiled and worked just fine. Compiler said: 'warning: use of 'auto' in parameter declaration only available with -fconcepts'
A Template solution works nicely. template void printArray(const std::array& array) { for (size_t i = 0; i < S; ++i) { // pre increment eliminates a copy that post increment performs. a little faster std::cout
New drinking game: Take a shot everytime Cherno tells us he will cover it in a future video. :D
I'd be falling out of my fucking chair.
I know it's quite funny, maybe little annoying but really, he can't cover everything in one video. We should be thankful for him even making those videos for free, for us. Hope you guys understand him.
ahhaha it's a suicide pact
@@geiger21 Yeah it ain't no big deal to me man, I completely get it. Can't speak for others of course. I just thought it was funny and figured I would make light of it is all.
I know right!
It is comical and want to give him hell but I know how complicated this is and impossible to cover in a few minutes.
I have to say he has covered quite a lot
The hardest part in C++ is deciding which thing to use
So true man. I guess it just comes with practice.
that was big problem for me when I tried OpenGL. So I gave it a try in C. The difference is huge. I no longer need to decide whether to use std::vector, regular array, something else, I just need to use malloc and then eventually realloc. I like that simplicity.
^^^^^^^^
@@geiger21 Well, you can write C++ codes without using STL stuffs...
Doesn't really matter what the size is.
template
void printArray(array a)
{
for (auto &i : a)
{
cout
we can also use "auto&" in the function parameter.
@@Dhruvpatel-gb4pv I actually don't know using auto in a parameter of a function is good or not, that sounds dangerous.
@@Dhruvpatel-gb4pv I'm surprised, but it works. I just guess the compiler treats it as a kind of template. As long as you don't call it in the code, it doesn't check if the argument has a size function. Or if it provides [] operator. If you pass something that, when substituted for auto is not valid you just get a compiler error. I've just checked it - it behaves exactly like a template. I tried to create a header file and definition file containing a function with auto argument - it works only when it's defined in the header. So - you can use a proper template instead, or just leave auto. Compiler doesn't seem to care, however VS autocomplete prefers a template over auto.
@@Dhruvpatel-gb4pv didn't work for me, I don't know why
@@Dhruvpatel-gb4pv I tried at first. But it doesn't work. Visual Studio threw an error.
It's worth noting that the size() function is also constexpr, so it doesn't actually return 5, but rather the compiler will just replace the function call itself with 5, so something like:
int s = ary.size();
literally becomes
int s = 5;
with no function call at runtime.
Thanks for the elaboration.
what’s the difference between inline and constexpr then?
thanks bro from steins gate
@@toao_rainyssorry for the delayed response. I didn't get a notification for this comment. inline means "please copy this code body into the places that call it instead of having it be an actual function call" and constexpr means "please calculate this out at compile time instead of figuring it out at runtime". This is strongly preferred to declaring constants with #define, etc. These days you don't really need to tell the compiler to inline, as it will do so when appropriate, and if it's not appropriate then it will ignore the directive even if you use it.
@@khatharrmalkavian3306Your explanation really helped, thanx
the best solution in my opinion is this:
template
void PrintArray(const std::array& data) {
for(int i = 0; i < data.size(); ++i) {
}
}
will not work, replace it with
@@alanyoung7045 Why so? Can you explain a bit more? I'm interested.
template
void printArray(T(&arr)[size])
{
}
I know, I digged your comment up, yeay a golden shovel for me.
@@rysiexo Hey, I'm new to templates. What is this syntax you are you using in the printArray parameters list (T(&arr)[size])?
@@alanyoung7045 or just call it template, since size_t is just a typedef of unsigned integer
I think there is one crucial thing to note:
Bounds checking with std::array [] operator is not guaranteed in debug mode. If anyone wants to make sure that they have bounds checking, they should use the .at() instead of the [] operator to access array elements since bounds checking with .at() method is required by c++ standard, but it is not the case for the [] operator. Bounds checking is always enabled with .at() method, regardless of the build type of your program, meaning it's built into the program even when compiling in release mode with compiler optimization.
For MSVC, as @cherno has shown, the [] operator supports bounds checking and disables it during release builds. But for the compiler I am using, which is GCC, bounds checking is completely none-existent with [] operator.
Anyways, thanks for your awesome videos. I have learned a lot from your content and your videos are with all seriousness life-changing to me.
template
void PrintArray(std::array& arr)
{
for (int i = 0; i < arr.size(); i++)
{
std::cout
Imankalyan maity To improve on this, you could just use N in your for loop instead of arr.size(). This way, you do not incur any runtime cost of evaluating the size() function and instead just use an int literal.
@@Cheddar2012 You should always used unsigned integers to keep the size, but nevertheless this was pretty much the solution.
@@Cheddar2012 I bet arr.size() is a constexpr, so no runtime cost anyway.
@@valizeth4073 Is there a cpu cost difference between signed and unsigned, or are you just saying out of principle?
That doesn't work for me.
"Stacks are stored in the arrays" - Cherno 2018. Well.. He *almost* said it.
Without checking if this compiles, I think the answer to the question at 4:00 is
template
void PrintArray(const array& data) {
// Do Stuff
}
Amirite?
This is what I came up with, too. Unless we wanted to modify the array, but that’s an easy fix lol
explanation to your question:
We use template to get the data and size
template
void print( const std::array & Data)
{
for ( T i : Data)
std::cout
As most of the guys here have guessed, the correct way to print an std::array is to use a template function.
Hohewer, I need to show off, so here's a function to print any iterable collection passing its begin() and end()
.
template
void printCollection(Iterator first, Iterator last)
{
for (auto it = first; it < last; ++it) {
std::cout
that's like . . . pythonic? idk
@@VarunSingh000 I don't know Python much, but this reminds me of C#'s methods for working with any IEmumerable collections. It's better than C++ STL way like in my example, as from the outside you just pass a collection itself, not these two separate "begin" and "end" things. And this collection later provides means to iterate over itself, but this happens INSIDE of a method. So iterators are hidden, as all implementation details should be.
Python is a beautuful language, by the way. I just prefer typed languages
I think the best solution to the array size function parameter function is to make use of auto declarations as function arguments from C++20. The below compiles perfectly (tested on gcc):
#include
#include
void PrintArray(const auto& data)
{
std::cout
you may want to reconsider using unnecessary if-else statements, as those seriously slow down your code.
that's really good
#include
#include
void test(auto& array) { for (auto &element : array) { std::cout
@@germanassasin1046This is mostly untrue. If/else statements are nearly ALWAYS more performant if written branchless. The branch prediction will do most of the heavy lifting, but an if/else nearly always ends up as a test/je/jnz. In the above example the predictor is only "warming up" on such a small array so branchless will out perform if/else. On a larger array, well, now you start to get a win/break-even with branchless because the condition only occurs at the end of the array. But start to use variable sized arrays and branchless will always will however good your optimizing compiler is. The downside to branchless is really the complexity and understandable logic.
I dislike this C++20 feature badly. Now you completely obscure what the incoming argument type is. It's one stage away from writing ... auto i = 0 and use auto everywhere.
Great!! so sensible. I would like to add two point, hope you will be aligned with me.
1. Usage of static_assert and assert Functions with std::array:
static_assert and other assertion functions work effectively with std::array because its result is a compile-time constant, and conditions are evaluated at compile time.
Since std::array has a fixed size known at compile time, it is suitable for use in compile-time checks like static_assert.
2. Applicability of constexpr with std::array and std::vector:
constexpr can be effectively used with std::array as it is resolved at compile time and its size is known at compile time.
On the other hand, std::vector is a runtime container, and its size is determined at runtime. Therefore, it is not suitable for use in constexpr contexts.
using gsl::span of the Guidelines Support Library (is a Microsoft implementation of some of the types and functions described in the C++ Core Guidelines)
In 4:17, You can use Template
Have you considered making a tutorial on CMake? It might come in very useful for people looking to do cross-platform projects
what is cross-platform projects? is it the same as mixing languages in a project?
@@pedrocalorio1655 cross platform = windows, mac or linux + others
@@pedrocalorio1655 It reffers than you don't depend on the IDE+OS to have a proper portable project. Due to Make is cross platform, and some IDEs are too (like VSCode), you can set up an environment of c++, make and visual studio code in any OS.
CMake is just for people who aren't good enough to write a proper makefile.
4:03 I was randomly trying stuff, and the one that executed without compile time error was to make the printArray() function a template with size and types as parameters like so:
template
printArray(const std::array &array) {}
template
void PrintArray(T& a)
{
for (int i = 0; i < a.size(); i++)
{
std::cout
Thank you, i am grateful that there is person such you. It really helps to figure out in c++
you can use initializer list just like array:
eg:
std::array arr{1,2,3,4,5};
or:
std::array arr = {1,2,3,4,5};
For regular arrays, you can increase its size by one and add one special character at the end of it. Inside printArray() just loop until you hit special character and voila you have the correct size. You must use the type of the array element to calculate the correct size. Its not very fast I think but it works.
Or you can assign the size of the array to the first element of array.
Thank you for your lesson, it perfect. Super...
awesome series.
you should edit out the "challenges". not many watches youtube guides to be told to google or find another vid explaining the details of the vid you are watching to learn the details ;)
but awesome c++ series ^^
templates right away answer thanks to you man
Solution to pass the size as param when using STL Array.
Pass the size as a template.
Example
template
void PrintArray(std::array& data) {
/* do something* /
}
Here is one ^^
4:20 solution:
template
void PrintArray(std::array data)
{
for (int i = 0; i < _Size; i++)
std::cout
template
void PrintArray(const array_type& m_array)
{
cout
template
void print(array&array){
int size = array.size();
for (int i = 0; i < size; i++){
cout
I think that if you don't know the size, you can either use a template or a macro but I think you have explicitly said that macros are mostly bad except for debugging and too much templating can become dubious. Based on my current knowledge I would probably use a template.
Yes!
You could write it using a template:
This has the drawbacks of longer compile time (not that noticeable) and the exe file would be slightly larger because every different variant of that function needs to be created and compiled. Right?
template
void PrintArray(const std::array& data)
You can get the size of an array by dividing the total size by the size of one element which works cuz its contiguous memory:
int size = sizeof(arr)/sizeof(arr[0])
It is quite easy to get the size of a standard C array by sizeof(array)/sizeof(array[0]) or there's a C++ standard library method if you prefer.
@Ralph Reilly A decayed array is not an array so your comment is a non sequitur.
Iterator mimics pointer arithmetic, so std::array iterators are not an advantage over usual c++ array, but a way to get closer in functionality to the usual c++ array.
All standard algorithms, like sort(), work on bare c++ arrays:
int a[] = {3, 2, 1};
sort(a, a + 3); // it works
something strange is happening here.. when i turn on subtitles it only allows russian, when i change it to auto gen russian to >>English, the only subtitle that comes up is "high five i have beyonce and funding"+"intensive and accessories and frill"+ "new style extract"+"whats the trouble"+ "he contracted st"+"bad girl i like slow mo guys"
template
void func(const std::array& arr) {
cout
To get around the problem of not knowing the size of the array, you can add a template to your function which asks for the array size.
then of course use a for(auto& element : array) loop
nice overview once again! ^^
To the people suggesting templates with std::array, why not
template
void PrintArray(int *array) {
for(int i=0; i
Isn't adding too many std::array with varying sizes (say for the same data type) will increase the size of program memory (code segment)? The size stored as a literal in the compiled program and that template is for every size type at the cost of program size.
Answer is by template :
template
void printArray(const std::array< T, size >&data)
{
// now we don’t need to pass type and size explicitly
}
I attempted the challenge using a template function and extra feature for type of the array too:
template
void printArray(const std::array& arr) {
for(dataType& value : arr) {
std::cout
template void foo(std::array){...}
I think you should make qt and qt-opengl tutorial.
My solution would be a bit more general purpose:
template
void PrintArray(const std::array& array)
{
for(auto& x : array)
std::cout
can we just print until we hit the terminating zero? 4:20
My Solution:
template // cant use int instead of size_t because the size of container(std::array) is in *size_t*
void printData(std::array& data1)
{
for(auto val : data1)
std::cout
Templates (:
template
void PrintArray(const std::array& data)
{
for (int i = 0; i < data.size(); i++)
std::cout
template
void PrintArray(const T& arr){
for (int i=0; i
To answer 4:20, would you just not specify the size in the angular brackets? Or perhaps you'd make PrintArray a function taking a template argument?
template is correct. Otherwise your code would get pretty messy.
3:50 so does anyone know the answer? Pls enlighten me. Is it just templates?
my version of the answer to the question is: what if I recreate it whenever I use or change it every time, like a static variable. creating a new pointer and pointing to the new pointer then removing an array old version.
Just gonna mention that the size is almost impossible to determain for a pointer, there are tricks but they are definitivly not guaranteed to reveal the size. That's why you always write: (int argc, char** argv). The argv is just an array of string, but the size is unknown, so argc is passed as the size for argv.
Forty degree, finally a sane person that doesn't use square feet by crate inch type of unit !
4:18 maybe try using a void* to the reference of the array and then go from there...
Go how far though? That is the question, and also why we need the length
You should probably use complier explorer for showing code that is compiled. Real difference between an Fixed size array and a pool allocator?
template
void func(std::array& array)
{
std::cout
THAT IS GENIUS!
This would work, however you should probably use something other than T because is is meant for Type names.
And yeah, it's not necessary to pass the template argument to a template function, because the compiler calculates it itself at the compile time. However, you have to pass template arguments, when you create an object of a template class.
So, the function call like this - func(testing) - will work just fine.
template
void PrintData(const std::array& data)
{
for(int i = 0; i < data.size(); ++i)
{
std::cout
We should use template to pass STL array with size to function in
C++11 or we can use auto keyword in C++17
When can we expect a video on namespaces? They seem like such a powerful tool especially when wanting to optionally include libraries. I am sure there are many other uses beyond just code structure.
Other topic I would like to see is the exploration of extern "C" to prevent name mangling. Why is this used so much? What benefits/drawbacks does it provide.
Thanks for the vids. Been a good supplement to my learning by providing good context to concepts.
Not sure if you still have this problem 4 years later, but he has a dedicated video in the learning C++ series that you should take a look at. Coming from C# namespaces used to confuse me in C++
template void PrintArray(std::array array)...
10mins is a good length. Didn't feel short.
Another solution for printing most of STL containers (except std::map):
#include
#include
#include
#include
#include
#include
template
void print(const Container& container)
{
std::copy(std::begin(container), std::end(container), std::ostream_iterator(std::cout, " "));
}
int main()
{
std::array arr{ 1, 2, 3, 4, 5};
std::vector vec{ 6, 7, 8, 9, 10 };
std::list lst{ 11, 12, 13, 14, 15 };
std::set st{ 16, 17, 18, 19, 20 };
print(arr);
std::cout
Yeah, thanks) Fixed it.
I forgot that *value_type* of *std::set* is Key in constructor. But *std::map* needs additional processing anyway.
Make a video on naming conventions for c++ like function name ,class ,private member,..etc
A solution to handle both value type and array size
template
void printArray(const std::array& array)
{
for (int i = 0; i < N; i++)
{
std::cout
We can use "auto" in function parameter as of C++14 instead of mentioning the type name and array size.
You're not right. You can use standard algorithms with C-style array. For begin iterator you use a name of an array and for the end one - name + size.
To use differently sized std::array's in one function you need to make this function a template one like this:
template
void func(const std::array arr);
But you can use it for C-style arrays either:
template
void func(int arr[size]);
But yeah, the debugging layout is useful
void PrintArray(const auto& data) {
for (const auto& value : data) {
std::cout
2:38 lol the captions.
Arrays should be constant at compile time so whatever size the array is should be tied to some constant.
obj c stl array constructs allow for compile time checking for array sizes and types in its functions.
it totally can work pretty well。
My solution looks like something like this:
(in this case its always ints, but you could do a typename version too)
template
void PrintArraySize(const std::array& data)
{
for (size_t i = 0; i < data.size(); i++)
{
std::cout
For a version that takes any type we could write:
template
void PrintArraySize(const std::array& data)
{
for (size_t i = 0; i < data.size(); i++)
{
std::cout
I realise this video is 10 months old, but I wanted to point out you can just use the auto keyword, no template needed:
void PrintArray(const auto& data)
{
for (int i = 0; i < data.size(); i++)
{
cout
@@tommymuir6750 I too tried this but msvc says that 'auto' keyword isn't allowed here.
@@tommymuir6750 why constant I mean why not without constant. Anyway array will be in local scope so why to use constant in particular
Cherno, bruh, correct me if I'm wrong but isn't returning 5 actaully means the function stores this constant internally as an int? So yeah, it is not a variable in the sense that you can not change its value, but still, it must store this value somewhere. (Perhaps as a 'const int'.)
I mean, what does a compiler do when it encounters a constant like 5 through code? Doesn't it store it somewhere?
Thanks for all the effort you're taking to share with us. This channel is awesome! And fix that AC! ;)
It is just CPU instruction, so its hard-coded in your binary file. It wont be stored in memory at all.
compiler gives you just assembly code, something like:
add ax, 42
(add 42 (2E) to accumulator)
which looks in binary file like this (HEX):
05 2A 00
Are you going to talk about linked list? :))
can we have template there.
template
void PrintContainer(const T& container) {
for(int i=0; i < container.size(); i++ ){
std::cout
Thanks
{
cout
You can pass the address of std::array as void* ptr in function argument and by knowning the offset of size inside array class you can find it like this: int size = *(int*)(uintptr_t(ptr) + *size_offset*)
you surely can, but why? You can just make that a template function and pass a reference to the array and make the compiler infer the size.
@@ДмитроПрищепа-д3я Да, меня что-то понесло. Можно и так)
@@ДмитроПрищепа-д3яYou could do this, but the problem is that you're relying on the internal structure of the array object. Now whilst this might work, if you used a different compiler that lays out the object structure differently, it'll break badly.
I'm not objecting completely because using a pointer is easily the most efficient way of passing the array object. The problem really is that inside the function, you have to cast it back and as a void pointer, you don't know its actual type. A template is a good idea, but it's only really the same as having a function take an array and size argument.
How do writing
template
void PrintArray(const std::array& data)
{...}
and then
PrintArray(data);
will work ? I thought it should be wrote like that:
PrintArray(data);
Sorry if my english is bad I am french
As far as I understand, value of size is deduced before compiling, so you dont have to specify.
Class template argument deduction (CTAD) (since C++17):
As Zhuolin Fu said, in THIS case the compiler is going to deduce the template argument from the type of "data".
Challenge accepted:
Use for each or just calculate size of the array. I'm I stupid and I'm not understanding something or what?
Void printArray( int* arr)
{
for (auto i: arr) serial.println(i);
// or
For (int I = 0; I < sizeof(arr) / sizeof(int); i++)
//Int is default cuz this is parameter type, u can make template out of it
}
I don’t think std::arrays do bounds checking using the overloaded [] operator. You would have to use the `at(i)` method instead of [i].
template
void Print(std::array& arr) {
for (int i = 0; i < Size; i++) {
println(arr[i]);
}
}
my solution is:
template
void PrintArray(const std::array & data)
{
for (int i= 0; i < N; I++)
{
std::cout
intusiastic!!!!!!!!!!!
Passing as a const int for the size as
const int size = 5;
void print_std_array(std::array my_array) {
for (size_t i = 0; i < my_array.size(); i++) {
std::cout
I do have questions about performances:
1/ Imagine you want to create 1000 array with differents size. Because of the template behavior, wouldn't it copy theses 500 lines of code every time and makes your executable much much larger ?
2/ When you do data.size() in the for loop, because it is not an "inline" function doesn't it makes a function call every time it reaches data.size(), making your code slower ? Same question with the operator[] which is a not inline function
Thank you for thoses who will answer me and sorry for my bad english, I am french and I try to improve myself.
So i figured i could use
void PrintArray(auto array) {
...
}
to print any array.
However... I'm not sure why, but this seems to have problems as my IDE marks it as error and my compiler yells at me for using it even so the code compiled and worked just fine.
Compiler said: 'warning: use of 'auto' in parameter declaration only available with -fconcepts'
A Template solution works nicely.
template
void printArray(const std::array& array) {
for (size_t i = 0; i < S; ++i) { // pre increment eliminates a copy that post increment performs. a little faster
std::cout
Hey Cherno sorry for posting this late
4:05
Templates?
yes
The best solution with C++ 20 ➡
void PrintArray (const std::span& data) {
for (auto& : data) {
std::cout
4:15 Using a template?
template
void printArray (const std::array & data){
for(int i = 0; i < data.size(); i++){
std::cout
Why do you have a redundant return statement?
James Nguyen because i like it
Over specialised method signature - see my answer below.
Enrage Your answer is less safe though. If you pass in for example an std::map accidentally things will go bad real quick.
// simpler and works with std::vector / std::deque too
// also C++11 for
template
void printArray (const T& data){
for(auto &element : data)
std::cout
Since its a template, it produces different copies, right? So would the intermediate object file and/or the executable file occupy more space?
template
void PrintArray(const std::array& data)
{
for (unsigned int i = 0; i < size; i++)
{
std::cout
hope u got aircondition after 5 years of hard work
😂
Solution to your question:
#include
#include
template
void Print(const std::array& arr)
{
for (int i = 0; i < arr.size(); i++)
{
std::cout
template
void printArray(const std::array& arr) {
for (const T& item : arr)
std::cout
template
void printArray(const std::array& data)
{
for(int i=0;i
@Cherno : please do a STL container comparison video