Difference between `vector v;` and `vector v = vector();`What is the difference between #include...
If I deleted a game I lost the disc for, can I reinstall it digitally?
Would the Vulcan nerve pinch work on a Borg drone?
How to deal with an incendiary email that was recalled
It took me a lot of time to make this, pls like. (YouTube Comments #1)
Cookies - Should the toggles be on?
Why do neural networks need so many training examples to perform?
Avoiding morning and evening handshakes
Strange Sign on Lab Door
Normalization for two bulk RNA-Seq samples to enable reliable fold-change estimation between genes
Pronunciation of umlaut vowels in the history of German
Advice for a new journal editor
what does しにみえてる mean?
How to remove lines through the legend markers in ListPlot?
Why do no American passenger airlines still operate dedicated cargo flights?
Is it a fallacy if someone claims they need an explanation for every word of your argument to the point where they don't understand common terms?
Digits in an algebraic irrational number
Find some digits of factorial 17
What is 6÷2×(1+2) =?
Why is working on the same position for more than 15 years not a red flag?
Can an insurance company drop you after receiving a bill and refusing to pay?
Which one of these password policies is more secure?
Why did other German political parties disband so fast when Hitler was appointed chancellor?
Can a hotel cancel a confirmed reservation?
How to avoid being sexist when trying to employ someone to function in a very sexist environment?
Difference between `vector v;` and `vector v = vector();`
What is the difference between #include <filename> and #include “filename”?What are the differences between a pointer variable and a reference variable in C++?What is the difference between g++ and gcc?Do the parentheses after the type name make a difference with new?Difference between private, public, and protected inheritanceWhat is the difference between const int*, const int * const, and int const *?What is the easiest way to initialize a std::vector with hardcoded elements?Rule-of-Three becomes Rule-of-Five with C++11?Easiest way to convert int to string in C++Difference between Constructor and ngOnInit
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
Intuitively, I would never use the second version but I am not sure there much difference. It feels to me that the second line is simply a default constructor followed by a move assignment operator but I am really not sure.
I am wondering whether the second line is not somehow equivalent to
std::vector<int>* p = new std::vector<int>();
std::vector<int> v = *p;
or
std::vector<int> v3 = *(new std::vector<int>());
hence causing the vector itself to be on the heap (dynamically allocated). If it is the case, then the first line would probably be preferred.
How do these lines of code differ?
c++ constructor initialization
add a comment |
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
Intuitively, I would never use the second version but I am not sure there much difference. It feels to me that the second line is simply a default constructor followed by a move assignment operator but I am really not sure.
I am wondering whether the second line is not somehow equivalent to
std::vector<int>* p = new std::vector<int>();
std::vector<int> v = *p;
or
std::vector<int> v3 = *(new std::vector<int>());
hence causing the vector itself to be on the heap (dynamically allocated). If it is the case, then the first line would probably be preferred.
How do these lines of code differ?
c++ constructor initialization
Even when there are temporary objects, they won't be on the heap.
– Daniel H
1 hour ago
add a comment |
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
Intuitively, I would never use the second version but I am not sure there much difference. It feels to me that the second line is simply a default constructor followed by a move assignment operator but I am really not sure.
I am wondering whether the second line is not somehow equivalent to
std::vector<int>* p = new std::vector<int>();
std::vector<int> v = *p;
or
std::vector<int> v3 = *(new std::vector<int>());
hence causing the vector itself to be on the heap (dynamically allocated). If it is the case, then the first line would probably be preferred.
How do these lines of code differ?
c++ constructor initialization
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
Intuitively, I would never use the second version but I am not sure there much difference. It feels to me that the second line is simply a default constructor followed by a move assignment operator but I am really not sure.
I am wondering whether the second line is not somehow equivalent to
std::vector<int>* p = new std::vector<int>();
std::vector<int> v = *p;
or
std::vector<int> v3 = *(new std::vector<int>());
hence causing the vector itself to be on the heap (dynamically allocated). If it is the case, then the first line would probably be preferred.
How do these lines of code differ?
c++ constructor initialization
c++ constructor initialization
edited 1 hour ago
Remi.b
asked 1 hour ago
Remi.bRemi.b
5,949144798
5,949144798
Even when there are temporary objects, they won't be on the heap.
– Daniel H
1 hour ago
add a comment |
Even when there are temporary objects, they won't be on the heap.
– Daniel H
1 hour ago
Even when there are temporary objects, they won't be on the heap.
– Daniel H
1 hour ago
Even when there are temporary objects, they won't be on the heap.
– Daniel H
1 hour ago
add a comment |
3 Answers
3
active
oldest
votes
The 1st one is default initialization, the 2nd one is copy initialization; The effect is same here, i.e. initialize the object v
via the default constructor of std::vector
.
For std::vector<int> v = std::vector<int>();
, in concept it will construct a temporary std::vector
then use it to move-construct the object v
(note there's no assignment here). According to the copy elision (from C++17 it's guaranteed), it'll just call the default constructor to initialize v
directly.
Under the following circumstances, the compilers are required to omit
the copy and move construction of class objects, even if the copy/move
constructor and the destructor have observable side-effects. The
objects are constructed directly into the storage where they would
otherwise be copied/moved to. The copy/move constructors need not be
present or accessible, as the language rules ensure that no copy/move
operation takes place, even conceptually:
In the initialization of a variable, when the initializer expression
is a prvalue of the same class type (ignoring cv-qualification) as the
variable type:
T x = T(T(f())); // only one call to default constructor of T, to initialize x
BTW: For both cases, no std::vector
objects (including potential temporary) will be constructed with dynamic storage duration via new
expression.
add a comment |
Starting from C++17 there's no difference whatsoever.
There's one niche case where the std::vector = std::vector
initialization syntax is quite useful (albeit not for default construction): when one wants to supply a "count, value" initializer for std::vector<int>
member of a class directly in the class's definition:
struct S {
std::vector<int> v; // Want to supply `(5, 42)` initializer here. How?
};
In-class initializers support only =
or {}
syntax, meaning that we cannot just say
struct S {
std::vector<int> v(5, 42); // Error
};
If we use
struct S {
std::vector<int> v{ 5, 42 }; // or = { 5, 42 }
};
the compiler will interpret it as a list of values instead of "count, value" pair, which is not what we want.
So, the proper way to do it is
struct S {
std::vector<int> v = std::vector(5, 42);
};
add a comment |
You had asked:
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
?
As others have stated since C++17 there basically is no difference. Now as for preference of which one to use, I would suggest the following:
- If you are creating an empty vector to be filled out later then the first version is the more desirable candidate.
- If you are constructing a vector with either a default value as one of its members and or a specified count, then the later version would be the one to use.
- Note that the following two are different constructors though:
std::vector<int> v = std::vector<int>();
- Is not the same constructor as:
std::vector<int> v = std::vector<int>( 3, 10 );
- The 2nd version of the constructor is an overloaded constructor.
- Otherwise if you are constructing a vector from a set of numbers than you have the following options:
std::vector<int> v = { 1,2,3,4,5 };
- operator=( std::initializer_list)
- `std::vector v{ 1,2,3,4,5 };
- list_initialization
Here is the list of std::vector
constructors.
"Now as for preference" I would say for preferenceauto v = std::vector<int>();
is better.
– Slava
56 mins ago
@Slava It depends on the situation. Sometimes you don't want to bloat your code withauto
everywhere. Nothing wrong with using it in specific places, but not for everything. If you are using a ranged loop then by all means use auto to traverse through a container. However just to declare a variable; I prefer to see the container with its types so I know what the container details. Another example that is a bad case use for using auto is when using some 3rd party libraries such as Eigen. They have lazy evaluation on some things but not all and theauto
feature can lead to UB.
– Francis Cugler
51 mins ago
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f54937426%2fdifference-between-vectorint-v-and-vectorint-v-vectorint%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
3 Answers
3
active
oldest
votes
3 Answers
3
active
oldest
votes
active
oldest
votes
active
oldest
votes
The 1st one is default initialization, the 2nd one is copy initialization; The effect is same here, i.e. initialize the object v
via the default constructor of std::vector
.
For std::vector<int> v = std::vector<int>();
, in concept it will construct a temporary std::vector
then use it to move-construct the object v
(note there's no assignment here). According to the copy elision (from C++17 it's guaranteed), it'll just call the default constructor to initialize v
directly.
Under the following circumstances, the compilers are required to omit
the copy and move construction of class objects, even if the copy/move
constructor and the destructor have observable side-effects. The
objects are constructed directly into the storage where they would
otherwise be copied/moved to. The copy/move constructors need not be
present or accessible, as the language rules ensure that no copy/move
operation takes place, even conceptually:
In the initialization of a variable, when the initializer expression
is a prvalue of the same class type (ignoring cv-qualification) as the
variable type:
T x = T(T(f())); // only one call to default constructor of T, to initialize x
BTW: For both cases, no std::vector
objects (including potential temporary) will be constructed with dynamic storage duration via new
expression.
add a comment |
The 1st one is default initialization, the 2nd one is copy initialization; The effect is same here, i.e. initialize the object v
via the default constructor of std::vector
.
For std::vector<int> v = std::vector<int>();
, in concept it will construct a temporary std::vector
then use it to move-construct the object v
(note there's no assignment here). According to the copy elision (from C++17 it's guaranteed), it'll just call the default constructor to initialize v
directly.
Under the following circumstances, the compilers are required to omit
the copy and move construction of class objects, even if the copy/move
constructor and the destructor have observable side-effects. The
objects are constructed directly into the storage where they would
otherwise be copied/moved to. The copy/move constructors need not be
present or accessible, as the language rules ensure that no copy/move
operation takes place, even conceptually:
In the initialization of a variable, when the initializer expression
is a prvalue of the same class type (ignoring cv-qualification) as the
variable type:
T x = T(T(f())); // only one call to default constructor of T, to initialize x
BTW: For both cases, no std::vector
objects (including potential temporary) will be constructed with dynamic storage duration via new
expression.
add a comment |
The 1st one is default initialization, the 2nd one is copy initialization; The effect is same here, i.e. initialize the object v
via the default constructor of std::vector
.
For std::vector<int> v = std::vector<int>();
, in concept it will construct a temporary std::vector
then use it to move-construct the object v
(note there's no assignment here). According to the copy elision (from C++17 it's guaranteed), it'll just call the default constructor to initialize v
directly.
Under the following circumstances, the compilers are required to omit
the copy and move construction of class objects, even if the copy/move
constructor and the destructor have observable side-effects. The
objects are constructed directly into the storage where they would
otherwise be copied/moved to. The copy/move constructors need not be
present or accessible, as the language rules ensure that no copy/move
operation takes place, even conceptually:
In the initialization of a variable, when the initializer expression
is a prvalue of the same class type (ignoring cv-qualification) as the
variable type:
T x = T(T(f())); // only one call to default constructor of T, to initialize x
BTW: For both cases, no std::vector
objects (including potential temporary) will be constructed with dynamic storage duration via new
expression.
The 1st one is default initialization, the 2nd one is copy initialization; The effect is same here, i.e. initialize the object v
via the default constructor of std::vector
.
For std::vector<int> v = std::vector<int>();
, in concept it will construct a temporary std::vector
then use it to move-construct the object v
(note there's no assignment here). According to the copy elision (from C++17 it's guaranteed), it'll just call the default constructor to initialize v
directly.
Under the following circumstances, the compilers are required to omit
the copy and move construction of class objects, even if the copy/move
constructor and the destructor have observable side-effects. The
objects are constructed directly into the storage where they would
otherwise be copied/moved to. The copy/move constructors need not be
present or accessible, as the language rules ensure that no copy/move
operation takes place, even conceptually:
In the initialization of a variable, when the initializer expression
is a prvalue of the same class type (ignoring cv-qualification) as the
variable type:
T x = T(T(f())); // only one call to default constructor of T, to initialize x
BTW: For both cases, no std::vector
objects (including potential temporary) will be constructed with dynamic storage duration via new
expression.
edited 1 hour ago
answered 1 hour ago
songyuanyaosongyuanyao
92.1k11175240
92.1k11175240
add a comment |
add a comment |
Starting from C++17 there's no difference whatsoever.
There's one niche case where the std::vector = std::vector
initialization syntax is quite useful (albeit not for default construction): when one wants to supply a "count, value" initializer for std::vector<int>
member of a class directly in the class's definition:
struct S {
std::vector<int> v; // Want to supply `(5, 42)` initializer here. How?
};
In-class initializers support only =
or {}
syntax, meaning that we cannot just say
struct S {
std::vector<int> v(5, 42); // Error
};
If we use
struct S {
std::vector<int> v{ 5, 42 }; // or = { 5, 42 }
};
the compiler will interpret it as a list of values instead of "count, value" pair, which is not what we want.
So, the proper way to do it is
struct S {
std::vector<int> v = std::vector(5, 42);
};
add a comment |
Starting from C++17 there's no difference whatsoever.
There's one niche case where the std::vector = std::vector
initialization syntax is quite useful (albeit not for default construction): when one wants to supply a "count, value" initializer for std::vector<int>
member of a class directly in the class's definition:
struct S {
std::vector<int> v; // Want to supply `(5, 42)` initializer here. How?
};
In-class initializers support only =
or {}
syntax, meaning that we cannot just say
struct S {
std::vector<int> v(5, 42); // Error
};
If we use
struct S {
std::vector<int> v{ 5, 42 }; // or = { 5, 42 }
};
the compiler will interpret it as a list of values instead of "count, value" pair, which is not what we want.
So, the proper way to do it is
struct S {
std::vector<int> v = std::vector(5, 42);
};
add a comment |
Starting from C++17 there's no difference whatsoever.
There's one niche case where the std::vector = std::vector
initialization syntax is quite useful (albeit not for default construction): when one wants to supply a "count, value" initializer for std::vector<int>
member of a class directly in the class's definition:
struct S {
std::vector<int> v; // Want to supply `(5, 42)` initializer here. How?
};
In-class initializers support only =
or {}
syntax, meaning that we cannot just say
struct S {
std::vector<int> v(5, 42); // Error
};
If we use
struct S {
std::vector<int> v{ 5, 42 }; // or = { 5, 42 }
};
the compiler will interpret it as a list of values instead of "count, value" pair, which is not what we want.
So, the proper way to do it is
struct S {
std::vector<int> v = std::vector(5, 42);
};
Starting from C++17 there's no difference whatsoever.
There's one niche case where the std::vector = std::vector
initialization syntax is quite useful (albeit not for default construction): when one wants to supply a "count, value" initializer for std::vector<int>
member of a class directly in the class's definition:
struct S {
std::vector<int> v; // Want to supply `(5, 42)` initializer here. How?
};
In-class initializers support only =
or {}
syntax, meaning that we cannot just say
struct S {
std::vector<int> v(5, 42); // Error
};
If we use
struct S {
std::vector<int> v{ 5, 42 }; // or = { 5, 42 }
};
the compiler will interpret it as a list of values instead of "count, value" pair, which is not what we want.
So, the proper way to do it is
struct S {
std::vector<int> v = std::vector(5, 42);
};
answered 1 hour ago
AnTAnT
260k33419661
260k33419661
add a comment |
add a comment |
You had asked:
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
?
As others have stated since C++17 there basically is no difference. Now as for preference of which one to use, I would suggest the following:
- If you are creating an empty vector to be filled out later then the first version is the more desirable candidate.
- If you are constructing a vector with either a default value as one of its members and or a specified count, then the later version would be the one to use.
- Note that the following two are different constructors though:
std::vector<int> v = std::vector<int>();
- Is not the same constructor as:
std::vector<int> v = std::vector<int>( 3, 10 );
- The 2nd version of the constructor is an overloaded constructor.
- Otherwise if you are constructing a vector from a set of numbers than you have the following options:
std::vector<int> v = { 1,2,3,4,5 };
- operator=( std::initializer_list)
- `std::vector v{ 1,2,3,4,5 };
- list_initialization
Here is the list of std::vector
constructors.
"Now as for preference" I would say for preferenceauto v = std::vector<int>();
is better.
– Slava
56 mins ago
@Slava It depends on the situation. Sometimes you don't want to bloat your code withauto
everywhere. Nothing wrong with using it in specific places, but not for everything. If you are using a ranged loop then by all means use auto to traverse through a container. However just to declare a variable; I prefer to see the container with its types so I know what the container details. Another example that is a bad case use for using auto is when using some 3rd party libraries such as Eigen. They have lazy evaluation on some things but not all and theauto
feature can lead to UB.
– Francis Cugler
51 mins ago
add a comment |
You had asked:
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
?
As others have stated since C++17 there basically is no difference. Now as for preference of which one to use, I would suggest the following:
- If you are creating an empty vector to be filled out later then the first version is the more desirable candidate.
- If you are constructing a vector with either a default value as one of its members and or a specified count, then the later version would be the one to use.
- Note that the following two are different constructors though:
std::vector<int> v = std::vector<int>();
- Is not the same constructor as:
std::vector<int> v = std::vector<int>( 3, 10 );
- The 2nd version of the constructor is an overloaded constructor.
- Otherwise if you are constructing a vector from a set of numbers than you have the following options:
std::vector<int> v = { 1,2,3,4,5 };
- operator=( std::initializer_list)
- `std::vector v{ 1,2,3,4,5 };
- list_initialization
Here is the list of std::vector
constructors.
"Now as for preference" I would say for preferenceauto v = std::vector<int>();
is better.
– Slava
56 mins ago
@Slava It depends on the situation. Sometimes you don't want to bloat your code withauto
everywhere. Nothing wrong with using it in specific places, but not for everything. If you are using a ranged loop then by all means use auto to traverse through a container. However just to declare a variable; I prefer to see the container with its types so I know what the container details. Another example that is a bad case use for using auto is when using some 3rd party libraries such as Eigen. They have lazy evaluation on some things but not all and theauto
feature can lead to UB.
– Francis Cugler
51 mins ago
add a comment |
You had asked:
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
?
As others have stated since C++17 there basically is no difference. Now as for preference of which one to use, I would suggest the following:
- If you are creating an empty vector to be filled out later then the first version is the more desirable candidate.
- If you are constructing a vector with either a default value as one of its members and or a specified count, then the later version would be the one to use.
- Note that the following two are different constructors though:
std::vector<int> v = std::vector<int>();
- Is not the same constructor as:
std::vector<int> v = std::vector<int>( 3, 10 );
- The 2nd version of the constructor is an overloaded constructor.
- Otherwise if you are constructing a vector from a set of numbers than you have the following options:
std::vector<int> v = { 1,2,3,4,5 };
- operator=( std::initializer_list)
- `std::vector v{ 1,2,3,4,5 };
- list_initialization
Here is the list of std::vector
constructors.
You had asked:
What is the difference between
std::vector<int> v;
and
std::vector<int> v = std::vector<int>();
?
As others have stated since C++17 there basically is no difference. Now as for preference of which one to use, I would suggest the following:
- If you are creating an empty vector to be filled out later then the first version is the more desirable candidate.
- If you are constructing a vector with either a default value as one of its members and or a specified count, then the later version would be the one to use.
- Note that the following two are different constructors though:
std::vector<int> v = std::vector<int>();
- Is not the same constructor as:
std::vector<int> v = std::vector<int>( 3, 10 );
- The 2nd version of the constructor is an overloaded constructor.
- Otherwise if you are constructing a vector from a set of numbers than you have the following options:
std::vector<int> v = { 1,2,3,4,5 };
- operator=( std::initializer_list)
- `std::vector v{ 1,2,3,4,5 };
- list_initialization
Here is the list of std::vector
constructors.
edited 56 mins ago
answered 1 hour ago
Francis CuglerFrancis Cugler
4,78611227
4,78611227
"Now as for preference" I would say for preferenceauto v = std::vector<int>();
is better.
– Slava
56 mins ago
@Slava It depends on the situation. Sometimes you don't want to bloat your code withauto
everywhere. Nothing wrong with using it in specific places, but not for everything. If you are using a ranged loop then by all means use auto to traverse through a container. However just to declare a variable; I prefer to see the container with its types so I know what the container details. Another example that is a bad case use for using auto is when using some 3rd party libraries such as Eigen. They have lazy evaluation on some things but not all and theauto
feature can lead to UB.
– Francis Cugler
51 mins ago
add a comment |
"Now as for preference" I would say for preferenceauto v = std::vector<int>();
is better.
– Slava
56 mins ago
@Slava It depends on the situation. Sometimes you don't want to bloat your code withauto
everywhere. Nothing wrong with using it in specific places, but not for everything. If you are using a ranged loop then by all means use auto to traverse through a container. However just to declare a variable; I prefer to see the container with its types so I know what the container details. Another example that is a bad case use for using auto is when using some 3rd party libraries such as Eigen. They have lazy evaluation on some things but not all and theauto
feature can lead to UB.
– Francis Cugler
51 mins ago
"Now as for preference" I would say for preference
auto v = std::vector<int>();
is better.– Slava
56 mins ago
"Now as for preference" I would say for preference
auto v = std::vector<int>();
is better.– Slava
56 mins ago
@Slava It depends on the situation. Sometimes you don't want to bloat your code with
auto
everywhere. Nothing wrong with using it in specific places, but not for everything. If you are using a ranged loop then by all means use auto to traverse through a container. However just to declare a variable; I prefer to see the container with its types so I know what the container details. Another example that is a bad case use for using auto is when using some 3rd party libraries such as Eigen. They have lazy evaluation on some things but not all and the auto
feature can lead to UB.– Francis Cugler
51 mins ago
@Slava It depends on the situation. Sometimes you don't want to bloat your code with
auto
everywhere. Nothing wrong with using it in specific places, but not for everything. If you are using a ranged loop then by all means use auto to traverse through a container. However just to declare a variable; I prefer to see the container with its types so I know what the container details. Another example that is a bad case use for using auto is when using some 3rd party libraries such as Eigen. They have lazy evaluation on some things but not all and the auto
feature can lead to UB.– Francis Cugler
51 mins ago
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f54937426%2fdifference-between-vectorint-v-and-vectorint-v-vectorint%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Even when there are temporary objects, they won't be on the heap.
– Daniel H
1 hour ago