Fixed Construction Guarantee: Fill & Download for Free

Shooting down an SR-71 running away from you is much more difficult than hitting a B-70 coming towards you.The key difference is that the SR-71 was a relatively stealthy aircraft for its’ time…it’s shape and special paint gave it some degree of “low observability” versus radars of the era. By the time Soviet radars did see it, the Blackbird would be nearly right on top of them. So every attempted missile firing against it was a stern chase, i.e. the missile was fired after it had already passed, and was vainly trying to catch up on a target which was already exiting the area.In contrast, the B-70 was “anti-stealth” - the bomber’s unusual shape and stainless-steel construction guaranteed that Soviet radars of the 1960s & 70s would’ve seen it coming long before it entered Soviet airspace. With the extra warning time, those same missiles which had no hope of CHASING a fleeing Mach 3.2 target would be much more capable versus an approaching target of nearly the same speed. That likely would give the other side a decent chance of launching MiG-25s on an intercept course as well.Further, other bombers were able to avoid the radar/missile threat by flying very low…. that was not a serious option for the B-70: it could only reach it’s Mach 3 speed at high altitudes, where it was most visible to radars and vulnerable to missiles. The source of it’s strength held the key to it’s weakness.Last but certainly not least: the B-70 would’ve carried a smaller bombload than the B-52.See the bomb bay? No? Hint: its a small rectangular section just behind the nose wheel well. Its about the only detail of that plane which is NOT impressive, but its kinda important when the shooting starts.So an unproven, very expensive weapons system, which carries LESS than it’s predecessor, demonstrated a potentially “mission-killer” flaw which could not be worked around or fixed. If you were a General in the Pentagon, what would you have decided? Even if you personally loved the plane, you still have to look at the numbers objectively.Personally, I would’ve recommended it be handed over to NASA for projects such as mothership for stretched X-15. Ahh, what might’ve been…

Fixed Price/Lump Sum: Maybe the most common contract type. This is best used when the design team has assembled complete or nearly complete drawings for a contractor to price out.Cost Plus: Owner pays actual costs of all construction to contractor with an agreed upon fee. Low bidding is not necessarily the deciding factor in selecting a contractor in this situation. Cost plus contracts can expose the owner to high costs as there is not technically a limit to the construction.Guaranteed Maximum Price (GMP): In this situation the owner pays the contractor the cost of the construction at an agreed upon or bidded sum from a contractor. If the construction costs exceed the GMP value, then the contractor is responsible for the extra costs.Unit Price: The contractor will provide the owner with pricing on various portions or area of the project. The owner would only pay for actual units that the contractor installs.

Objection, your Honor! Question assumes facts not in evidence!tl;drArrays and std::vector should perform identically when used properly. Algorithms that work on elements in contiguous storage when given a pointer, iterator, range, or view will see no difference.It's possible, however to create performance issues with either, and they happen in different circumstances.In the answer below, “array" refers to C style arrays, std::array, and dynamic arrays allocated with new[] (or moral equivalent*), unless stated otherwise. “Vector" refers to std::vector. Also, I am ignoring constexpr for now, as that's a separate kettle of fish.Creating, Destructing, Indexing, and IteratingArrays have different overheads than vectors:Array:Constructs all elements when array is created.Destructs all elements when array is destroyed.Cannot be resized, so all construction/destruction overhead occurs at the boundaries of the array's lifetime.No additional storage penalty beyond the elements themselves, except a pointer in the case of a dynamic array.The array may reside in static storage, automatic storage (“the stack"), or dynamic storage (“the heap").Random element access via a[i] is simple pointer arithmetic and dereference: *(a + i).Iterators are just T*.Vector:Constructs elements when the vector's size() increases.Destructs elements when the vector's size() decreases.Copies/moves elements when changing its capacity().Typically requires ~3 pointers worth of storage for the vector itself, beyond what it allocated for the elements. Unless you use a custom allocator, elements are always allocated in dynamic storage (“the heap").Random element access via a[i] should be simple pointer arithmetic and dereference: *(a+i).Iterators should be T* or something very close to it, such as a type wrapper around T*.On those last two bullets, I say “should be.” Some platforms can add significant overhead in debug builds, rendering those last two bullets false. (Example.) To get a meaningful measurement, turn off debug and turn on optimization. I will tacitly assume optimized non-debug builds from here on.Arrays and vectors have different overheads. But look closely: those overhead differences involve creation and destruction, not element access. Arrays and vectors store elements contiguously in memory. The exact same object code can operate on the contents of either, because array and vector store the elements identically.That leaves creation and destruction. If creation and destruction dominate your runtime as compared to element access, you're probably doing something wrong.Scenario 1Suppose I have a class Heavy whose constructors are costly, including its copy constructor. For the sake of argument, let's say it takes 1ms. And let's say it's not a movable type.How much time do each of these statements take?Heavy a[1000]; std::vector<Heavy> v; v.reserve(1000); Line 1 will take ~1000ms, because it constructs all 1000 Heavy instances. Line 2 takes an immeasurably small amount of time. Line 3 costs a single call to operator new, which should be very quick in most circumstances.Now, how about these three statements? Aa[0] = Heavy(/*details*/); v.push_back(Heavy(/*details*/)); v.emplace_back(/*details*/); Line 1 costs another 1ms, even though we already had an instance in a[0]. We wasted work earlier. Line 2 costs 2ms: 1ms to construct the argument, and another 1ms to default construct an element to copy the argument into. It's better than the array only if we do this fewer than 1000 times. Line 3 only takes 1ms, because it constructs in-place.The array was definitely slower here. Regardless of how many elements you use, the emplace_back strategy intrinsically constructs half as many Heavy instances, because it never default constructs. If you use fewer than 1000 elements typically, the gains are even larger. Even push_back pulls ahead, because vector default-construct fewer Heavy instances than an array will.There’s a corresponding scenario with destruction that mirrors construction. I’ll let you ponder it.Scenario 2Let's benchmark a couple loops:for (int i = 0; i < N; ++i) {  int a[N];  for (int j = 0; j < N; ++j) {  a[j] = j ^ i;  }  do_something(std::begin(a), std::end(a)); } vs.for (int i = 0; i < N; ++i) {  std::vector<int> v;  for (int j = 0; j < N; ++j) {  v.push_back(j ^ i);  }  do_something(std::begin(v), std::end(v)); } The second one is probably noticeably slower than the first one. It might improve slightly if we add v.resize(N) after line 2, and use v[i] rather than push_back().Does that mean std::vector is slower? Not really. You're holding it wrong.Yes, it we'd like std::vector to drop in nicely like this and Just Work™, but we need to do a little more work to make it perform well. Jobs' line fits, I hate to say.The fundamental issue here is that the second version ends up doing a lot of unnecessary dynamic allocation.The fix:std::vector<int> v; v.resize(N); for (int i = 0; i < N; ++i) {  for (int j = 0; j < N; ++j) {  v[j] = j ^ i;  }  do_something(std::begin(v), std::end(v)); } In this case, because we are overwriting the entire vector, I didn’t need to do anything special to reuse it. If we were using a different data type that benefits from more precise construction/destruction, this general pattern also works:std::vector<T> v; v.reserve(MAX_SIZE); for ( ... ) {  // use push_back or emplace_back or  // back_inserter or what-have-you.   do_something(std::begin(v), std::end(v));  v.clear(); // resets size to 0. } Now you might wonder if an array was a better fit for Scenario 2. It depends!Questions to consider the next time you’re faced with a choice:Is N actually a compile time constant?Is N large enough that we benefit from dynamic allocation on the heap?If we used a class type instead of something simple like int, would we benefit from incremental construction?Values, Copies, and MovesAre there other ways to misuse either of these? Certainly! The previous section compared one array to one vector. What if we have multiple arrays or multiple vectors to move around?You may have heard the terms value semantics and move semantics pop up in C++ conversations.Value semantics refers to treating objects as values by default, and each value stands on its own, in its own variable. Value semantics stand in contrast to pointer or reference semantics, where you could have multiple aliases for a given item. Value semantics goes hand-in-hand with referential transparency.Value semantics typically implies making copies. When you pass arguments by value, you're passing copies. For expensive-to-copy objects, C++ has also long provided pass-by-const-reference, which behaves almost like pass-by-value.In modern C++, it's perfectly reasonable to have a C++ function return a std::vector or std::array. For example, suppose I want to create a lookup table of size N at run-time, and I have good reason for doing this at runtime.Either of these signatures is fine:std::array<T, N> generate_table_a(/*args*/); std::vector<T> generate_table_v(/*args*/); In fact, those get even more interesting as lambdas to provide complex initializers. But I digress.How do we make that efficient? It turns out to be a little easier for the vector than the array in general.C++ permits copy elision. So, every C++ compiler worth its salt has implemented Return Value Optimization (RVO) and Named Return Value Optimization (NRVO) for eons.RVO elides the copy when you directly construct the return value. That is, the return statement directly invokes a constructor for the return type. And in C++17, you're guaranteed you'll directly construct the return value in its destination. RVO is mandatory, and is no longer considered copy elision.std::array<int, 5> rvo_example() {  return std::array<int, 5>{ 1, 2, 3, 4, 5 }; }   // Copies elided by RVO (pre-C++17). // Direct construction guaranteed in C++17. std::array<int, 5> arr = rvo_example(); NRVO kicks in when you return a named value—a local variable—from within the function. Compilers vary in cleverness, but we can establish a baseline: If you declare one variable to hold the return value, and all return statements return that variable, chances good are NRVO will kick in.std::vector<int> nrvo_example() {  std::vector<int> v;  for (int i = 0; i < 10; ++i) {  v.push_back(calculation(i));  }  return v; // <-- NRVO here } C++ doesn't guarantee NRVO happens. Before C++17, it does not guarantee RVO happens, either. But, it’s a reasonable bet your compiler implements it when optimization is on.So, let's go back to our lookup table example:std::array<T, N> generate_table_a(/*args*/) {  std::array<T, N> table;  // ...complex calculations...  return table; // <-- wants NRVO, badly! }  std::vector<T> generate_table_v(/*args*/) {  std::vector<T> table;  // ...complex calculations...  return table; // <-- also wants NRVO! } Suppose something happens, and for some reason NRVO doesn’t kick in. Or worse, we end up needing multiple return variables for some reason and NRVO isn’t possible.For example, suppose you don’t know until after you’ve generated a pair of tables which table you need to return:std::array<T, N> generate_table_a(/*args*/) {  std::array<T, N> table1;  std::array<T, N> table2;  // ...complex calculations...  if (cond) {  return table1; // <-- no NRVO. Sad...  } else {  return table2; // <-- no NRVO. Sad...  } }  std::vector<T> generate_table_v(/*args*/) {  std::vector<T> table1;  std::vector<t> table2;  // ...complex calculations...  if (cond) {  return table1; // <-- no NRVO. But... move?  } else {  return table2; // <-- no NRVO. But... move?  } } In that case, both functions will become much more expensive, since we can't create the result directly in its destination. What can we do?This is where move semantics comes in. Move semantics stand in contrast to copy semantics. Rather than copying a value, why not just move it, if you know the old variable won't need it any longer? C++ uses value categories to identify values that are move candidates: prvalues, which generally represent result of a computation, and xvalues, which are “expiring” values. Notably, values in these categories aren’t typically in named variables.Moves usually work by stealing resources: If you move one std::vector to another, they likely just exchange some pointers as opposed to copying (or moving) the values in the vector. Moving a vector is an [math]O(1)[/math] operation.I mentioned that moves kick in for value categories that aren’t associated with named variables. Named variables are typically lvalues. How do we move a value from a named variable? The library function std::move[1] returns an rvalue reference to its argument. It doesn’t actually move anything, but it does make the value a candidate for moves:std::vector<int> v1 = { /*stuff*/ }; std::vector<int> v2;  v2 = std::move(v1);  // v2 now holds /*stuff*/ // v1 is an unspecified but valid state. We can make generate_table_v() more efficient by moving the result:std::vector<T> generate_table_v(/*args*/) {  std::vector<T> table1;  std::vector<t> table2;  // ...complex calculations...  if (cond) {  return std::move(table1);  } else {  return std::move(table2);  } } And actually, guess what? That std::move is superfluous. It turns out that when you return a local variable, it’s automatically a candidate for a move, since the compiler knows the variable’s lifetime is ending. So actually, we didn’t need to do anything special to get the move semantics:std::vector<T> generate_table_v(/*args*/) {  std::vector<T> table1;  std::vector<t> table2;  // ...complex calculations...  if (cond) {  return table1; // Eligible to move!  } else {  return table2; // Eligible to move!  } } What about arrays? std::array doesn’t have an independently allocated resource you can steal like std::vector does. std::array allocated its storage right there on the stack. There is no internal pointer you can swap. The compiler will instead try to move the elements, which can help, but that’s still an [math]O(n)[/math] operation. So, move semantics don’t speed up the final version of generate_table_a(), unless the elements themselves benefit from the moves.So here’s another case where vectors end up being more efficient than arrays. You can efficiently move a vector, but you can’t efficiently move an array.SummaryIn general, std::vector should not be slower than an array. However, you should keep some things in mind:Arrays and vectors store elements identically: contiguous storage that can be indexed with ordinary pointer arithmetic. Under normal circumstances, an algorithm won’t be able to tell whether it’s operating on an array or a vector.Measure optimized production builds. Debug build may add a lot of error checking overhead that skews the results. Heavy debug iterators can really slow things down.Be mindful of what you construct, and when. Arrays default construct all their elements up-front, whereas vectors construct incrementally.Be mindful of what you allocate, and when. Vectors allocate storage on the heap, and those calls add up. If you know how much space you might use, consider calling reserve(). If you declare a vector inside in a loop, consider moving the declaration outside and use clear() to reuse the already-allocated storage.Value semantics push you away from passing data around by pointers or references. That often results in expensive copies, even when you didn’t need a copy since the thing you’re copying from is about to go away. C++ offers some tricks to elide those copies, but they don’t always apply. Vectors offer an [math]O(1)[/math] option, moves, that isn’t available to arrays.So, are vectors slower than arrays? In some situations, yes. But, arrays are also slower than vectors in other situations.For the most common situation, random element access, both should be the same.AddendumBulat Ziganshin points out a real potential problem with some compilers and/or compiler options: The compiler may think the pointer inside std::vector aliases another pointer or value in your code. This could inhibit optimizations that the compiler would normally apply to arrays.Compiler flags such as -fstrict-aliasing can help, although not always.As a result, these two loops examples might perform differently:extern void opaque(double *);  void array_version() {  double d[1000];  for (int i = 0; i < 1000; i++) {  d[i] = i;  }  opaque(d); // prevents "deadcoding" the loop }  void vector_version() {  std::vector<double> d;  d.resize(1000);  for (int i = 0; i < 1000; i++) {  d[i] = i;  }  opaque(d.data()); // prevents "deadcoding" the loop } Take a look at the GCC and Clang output for those two loops here: Compiler Explorer - C++In the compiler output above, it appears the compiler has done a good job of figuring it out.If you do find a case where conservative alias analysis bites you, try getting a pointer to the underlying data, and using that:double *dp = d.data(); for (int i = 0; i < 1000; i++) {  dp[i] = i; } Or use an algorithm that works with iterators, so the only reference to std::vector’s internal pointers happen at the start of the loop.In this simple example, neither of those steps seemed to be necessary.Addendum 2Hubert Wagner points out in the comments that you could also run into performance anomalies around the fact that std::vector returns an unsigned std::size_t for its size(), and coerces indices provided to operator[] to std::size_t.Thus, if you use a signed index and pass it to operator[] or compare it against size(), you may incur a conversion penalty.You can avoid that by using std::size_t for an index. Or, use range-based for if it’s applicable.*For example, std::make_unique<T[]>(size_t).Footnotes[1] std::move - cppreference.com