assignment operator unique_ptr

cppreference.com

Std::unique_ptr<t,deleter>:: operator=.

If Deleter is not a reference type, requires that it is nothrow- MoveAssignable . If Deleter is a reference type, requires that std:: remove_reference < Deleter > :: type is nothrow- CopyAssignable .

• This assignment operator of the primary template only participates in overload resolution if U is not an array type and unique_ptr < U,E > :: pointer is implicitly convertible to pointer and std:: is_assignable < Deleter & , E && > :: value is true .
• This assignment operator in the specialization for arrays, std::unique_ptr<T[]> behaves the same as in the primary template, except that will only participate in overload resolution if all of the following is true:
• U is an array type
• pointer is the same type as element_type*
• unique_ptr<U,E>::pointer is the same type as unique_ptr<U,E>::element_type*
• unique_ptr<U,E>::element_type(*)[] is convertible to element_type(*)[]
• std:: is_assignable < Deleter & , E && > :: value is true

Note that unique_ptr 's assignment operator only accepts rvalues , which are typically generated by std::move . (The unique_ptr class explicitly deletes its lvalue copy constructor and lvalue assignment operator.)

[ edit ] Parameters

[ edit ] Return value

[ edit ] example, [ edit ] defect reports.

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 13 April 2022, at 08:00.
• This page has been accessed 280,042 times.
• Privacy policy
• About cppreference.com
• Disclaimers

• <cassert> (assert.h)
• <cctype> (ctype.h)
• <cerrno> (errno.h)
• C++11 <cfenv> (fenv.h)
• <cfloat> (float.h)
• C++11 <cinttypes> (inttypes.h)
• <ciso646> (iso646.h)
• <climits> (limits.h)
• <clocale> (locale.h)
• <cmath> (math.h)
• <csetjmp> (setjmp.h)
• <csignal> (signal.h)
• <cstdarg> (stdarg.h)
• C++11 <cstdbool> (stdbool.h)
• <cstddef> (stddef.h)
• C++11 <cstdint> (stdint.h)
• <cstdio> (stdio.h)
• <cstdlib> (stdlib.h)
• <cstring> (string.h)
• C++11 <ctgmath> (tgmath.h)
• <ctime> (time.h)
• C++11 <cuchar> (uchar.h)
• <cwchar> (wchar.h)
• <cwctype> (wctype.h)

Containers:

• C++11 <array>
• <deque>
• C++11 <forward_list>
• <list>
• <map>
• <queue>
• <set>
• <stack>
• C++11 <unordered_map>
• C++11 <unordered_set>
• <vector>

Input/Output:

• <fstream>
• <iomanip>
• <ios>
• <iosfwd>
• <iostream>
• <istream>
• <ostream>
• <sstream>
• <streambuf>

Multi-threading:

• C++11 <atomic>
• C++11 <condition_variable>
• C++11 <future>
• C++11 <mutex>
• C++11 <thread>
• <algorithm>
• <bitset>
• C++11 <chrono>
• C++11 <codecvt>
• <complex>
• <exception>
• <functional>
• C++11 <initializer_list>
• <iterator>
• <limits>
• <locale>
• <memory>
• <new>
• <numeric>
• C++11 <random>
• C++11 <ratio>
• C++11 <regex>
• <stdexcept>
• <string>
• C++11 <system_error>
• C++11 <tuple>
• C++11 <type_traits>
• C++11 <typeindex>
• <typeinfo>
• <utility>
• <valarray>
• C++11 allocator_arg_t
• C++11 allocator_traits
• auto_ptr_ref
• C++11 bad_weak_ptr
• C++11 default_delete
• C++11 enable_shared_from_this
• C++11 owner_less
• C++11 pointer_traits
• raw_storage_iterator
• C++11 shared_ptr
• C++11 unique_ptr
• C++11 uses_allocator
• C++11 weak_ptr

enum classes

• C++11 pointer_safety
• C++11 addressof
• C++11 align
• C++11 allocate_shared
• C++11 const_pointer_cast
• C++11 declare_no_pointers
• C++11 declare_reachable
• C++11 dynamic_pointer_cast
• C++11 get_deleter
• C++11 get_pointer_safety
• get_temporary_buffer
• C++11 make_shared
• return_temporary_buffer
• C++11 static_pointer_cast
• C++11 undeclare_no_pointers
• C++11 undeclare_reachable
• uninitialized_copy
• C++11 uninitialized_copy_n
• uninitialized_fill
• uninitialized_fill_n
• C++11 allocator_arg

std:: unique_ptr

• a stored pointer : the pointer to the object it manages. This is set on construction , can be altered by an assignment operation or by calling member reset , and can be individually accessed for reading using members get or release .
• a stored deleter : a callable object that takes an argument of the same type as the stored pointer and is called to delete the managed object. It is set on construction , can be altered by an assignment operation , and can be individually accessed using member get_deleter .

Template parameters

Member types.

Member functions

Non-member function overloads.

Understanding unique_ptr with Example in C++11

The smart pointers are a really good mechanism to manage dynamically allocated resources. In this article, we will see unique_ptr with example in C++11. But we don’t discuss standard smart pointers from a library. Rather, we implement our own smart pointer equivalent to it. This will give us an idea of inside working of smart pointers.

Prior to C++11, the standard provided std::auto_ptr . Which had some limitations. But from C++11, standard provided many smart pointers classes. Understanding unique_ptr with example in C++ requires an understanding of move semantics which I have discussed here & here .

But before all these nuisances, we will see “Why do we need smart pointer in 1st place?”:

Why do we need smart pointers? #

• In the above code, the early return or throw statement, causing the function to terminate without variable ptr being deleted.
• Consequently, the memory allocated for variable ptr is now leaked (and leaked again every time this function is called and returns early).
• These kinds of issues occur because pointer variables have no inherent mechanism to clean up after themselves.
• Following class cleans-up automatically when sources are no longer in use:

smart_ptr aka std::auto_ptr from C++98 #

• Now, let’s go back to our func() example above, and show how a smart pointer class can solve our challenge:

• Note that even in the case where the user enters zero and the function terminates early, the Resource is still properly deallocated.
• Because of the ptr variable is a local variable. ptr destroys when the function terminates (regardless of how it terminates). And because of the smart_ptr destructor will clean up the Resource , we are assured that the Resource will be properly cleaned up.
• There is still some problem with our code. Like:

• In this case destructor of our Resource object will be called twice which can crash the program.
• What if, instead of having our copy constructor and assignment operator copy the pointer (“copy semantics”), we instead transfer/move ownership of the pointer from the source to the destination object? This is the core idea behind move semantics. Move semantics means the class will transfer ownership of the object rather than making a copy.
• Let’s update our smart_ptr class to show how this can be done:

std::auto_ptr , and why to avoid it #

• What we have seen above as smart_ptr is basically an std::auto_ptr which was introduced in C++98, was C++’s first attempt at a standardized smart pointer.
• However, std::auto_ptr (and our smart_ptr class) has a number of problems that make using it dangerous.
• Because std::auto_ptr implements move semantics through the copy constructor and assignment operator, passing an std::auto_ptr by value to a function will cause your resource to get moved to the function parameter (and be destroyed at the end of the function when the function parameters go out of scope). Then when you go to access your std::auto_ptr argument from the caller (not realizing it was transferred and deleted), you’re suddenly dereferencing a null pointer. Crash!
• std::auto_ptr always deletes its contents using non-array delete. This means std::auto_ptr won’t work correctly with dynamically allocated arrays, because it uses the wrong kind of deallocation. Worse, it won’t prevent you from passing it a dynamic array, which it will then mismanage, leading to memory leaks.
• Because of the above-mentioned shortcomings, std::auto_ptr has been deprecated in C++11, and it should not used. In fact, std::auto_ptr slated for complete removal from the standard library as part of C++17!
• Overriding the copy semantics to implement move semantics leads to weird edge cases and inadvertent bugs. Because of this, in C++11, the concept of “move” formally defined. And “move semantics” added to the language to properly differentiate copying from moving. In C++11, std::auto_ptr has been replaced by a bunch of other types of “move-aware” smart pointers: std::scoped_ptr , std::unique_ptr , std::weak_ptr , and std::shared_ptr .
• We’ll also explore the two most popular of these: std::unique_ptr (which is a direct replacement for std::auto_ptr ) and std::shared_ptr .

std::unique_ptr with example in C++11 #

• std::unique_ptr is the C++11 replacement for std::auto_ptr . It is used to manage use to manage any dynamically allocated object not shared by multiple objects. That is, std::unique_ptr should completely own the object it manages, not share that ownership with other classes.
• We can convert our smart_ptr we designed above into std::unique_ptr . And for that one thing, we can do is delete the copy constructor & assignment operator so that no one can copy smart pointer.
• As we are not allowing a copy of smart pointer we can’t pass our smart pointer to any function by value or return by value. And this is not good design.
• To pass or return by value, we can add move constructor & move assignment operator, so that while passing or returning by value, we would have to transfer ownership through move semantics. This way we can also ensure single ownership throughout the lifetime of the object.

• This is not the exact implementation of std::unique_ptr as there is deleter, implicit cast to bool & other security features included in an actual implementation, but this gives you a bigger picture of how std::unique_ptr is implemented.

References #

• https://www.learncpp.com/cpp-tutorial/15-1-intro-to-smart-pointers-move-semantics/
• https://stackoverflow.com/questions/106508/what-is-a-smart-pointer-and-when-should-i-use-one
• https://docs.microsoft.com/en-us/cpp/cpp/smart-pointers-modern-cpp?view=vs-2017

std::unique_ptr

Defined in header <memory> .

Declarations ​

Description ​.

std::unique_ptr is a smart pointer that owns and manages another object through a pointer and disposes of that object when the unique_ptr goes out of scope.

The object is disposed of, using the associated deleter when either of the following happens:

the managing unique_ptr object is destroyed

the managing unique_ptr object is assigned another pointer via operator = or reset()

The object is disposed of, using a potentially user-supplied deleter by calling get_deleter()(ptr) . The default deleter uses the delete operator, which destroys the object and deallocates the memory.

A unique_ptr may alternatively own no object, in which case it is called empty .

There are two versions of std::unique_ptr :

• Manages a single object (e.g. allocated with new );
• Manages a dynamically-allocated array of objects (e.g. allocated with new[] ).

The class satisfies the requirements of MoveConstructible and MoveAssignable, but of neither CopyConstructible nor CopyAssignable.

Type requirements ​

Deleter must be FunctionObject or lvalue reference to a FunctionObject or lvalue reference to function, callable with an argument of type unique_ptr<T, Deleter>::pointer .

Only non-const unique_ptr can transfer the ownership of the managed object to another unique_ptr . If an object's lifetime is managed by a const std::unique_ptr , it is limited to the scope in which the pointer was created.

std::unique_ptr is commonly used to manage the lifetime of objects, including:

• Providing exception safety to classes and functions that handle objects with dynamic lifetime, by guaranteeing deletion on both normal exit and exit through exception;
• Passing ownership of uniquely-owned objects with dynamic lifetime into functions;
• Acquiring ownership of uniquely-owned objects with dynamic lifetime from functions;
• As the element type in move-aware containers, such as std::vector , which hold pointers to dynamically-allocated objects (e.g. if polymorphic behavior is desired).

std::unique_ptr may be constructed for an incomplete type T , such as to facilitate the use as a handle in the pImpl idiom. If the default deleter is used, T must be complete at the point in code where the deleter is invoked, which happens in the destructor, move assignment operator, and reset member function of std::unique_ptr . (Conversely, std::shared_ptr can't be constructed from a raw pointer to incomplete type, but can be destroyed where T is incomplete). Note that if T is a class template specialization, use of unique_ptr as an operand, e.g. !p requires T 's parameters to be complete due to ADL.

If T is a derived class of some base B , then std::unique_ptr<T> is implicitly convertible to std::unique_ptr<B> . The default deleter of the resulting std::unique_ptr<B> will use operator delete for B , leading to undefined behavior unless the destructor of B is virtual. Note that std::shared_ptr behaves differently: std::shared_ptr<B> will use the operator delete for the type T and the owned object will be deleted correctly even if the destructor of B is not virtual.

Unlike std::shared_ptr , std::unique_ptr may manage an object through any custom handle type that satisfies NullablePointer. This allows, for example, managing objects located in shared memory, by supplying a Deleter that defines typedef boost::offset_ptr pointer ; or another fancy pointer.

Member types ​

Member functions ​

Modifiers ​

Observers ​

Single-object version, unique_ptr<T> ​

Array version, unique_ptr<T[]> ​

Non-member functions ​

Helper Classes ​

• Declarations
• Description
• Member types
• Member functions
• Non-member functions
• Helper Classes

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

My implementation for std::unique_ptr

I just finished learning about move semantics and realized that a nice practical example for this concept is unique_ptr (it cannot be copied, only moved).

For learning purposes, and as a personal experiment, I proceed to try to create my implementation for a smart unique pointer:

For a small set of test cases, this is working like the real unique_ptr .

However, it just seems too simple enough.

I have two questions regarding this code:

• Is it well-formed? i.e. does it follow common C++ standard and patterns (for example, should private members be declared before public ones?
• Am I missing something regarding functionality? Is there maybe a bug in my code that I'm not seeing?
• reinventing-the-wheel

• \$\begingroup\$ If there is something I can do to improve my question, feel free to comment any tips, don't just leave your downvote \$\endgroup\$ –  Matias Cicero Commented May 21, 2017 at 1:30
• \$\begingroup\$ I left a downvote and an edit. Wasn't that enough information? \$\endgroup\$ –  πάντα ῥεῖ Commented May 21, 2017 at 1:50
• 2 \$\begingroup\$ @πάνταῥεῖ You just added a missing tag. Do I deserve a downvote for that? \$\endgroup\$ –  Matias Cicero Commented May 21, 2017 at 2:18
• \$\begingroup\$ Do you really need to reinvent the square wheel? Can you elaborate bout why actually? \$\endgroup\$ –  πάντα ῥεῖ Commented May 21, 2017 at 3:04
• 1 \$\begingroup\$ Did you mean to omit the members that allow you to actually use a unique pointer? I mean, operator*() and operator->() . \$\endgroup\$ –  Toby Speight Commented May 22, 2017 at 11:06

2 Answers 2

Is it well-formed?

It compiles, so yes.

i.e. does it follow common C++ standard and patterns (for example, should private members be declared before public ones?

Personally I think so.

When reading the code I want to know the members so I can verify that the constructors initialize them all, as a result I usually put them first. But other people prefer to put all private stuff at the bottom.

Am I missing something regarding functionality?

Yes. Quite a lot.

Is there maybe a bug in my code that I'm not seeing?

Yes. It potentially leaks on assignment.

Code Review

Constructing from object.

That's exceedingly dangerous:

Use member initializing list.

You should always attempt to use the member initializer list for initializing members. Any non-trivial object will have its constructor called before the initializer code is called and thus it is inefficient to then re-initialize it in the code.

Member variable Names

Prefer not to use _ as the first character in an identifier name.

Even if you know all the rules of when to use them most people don't so they are best avoided. If you must have a prefix to identify members use m_ - but if you name your member variables well then there is no need for any prefix (in my opinion prefixes makes the code worse not better, because you are relying on unwritten rules. If you have good well-defined names (see self-documenting code) then members should be obvious).

The move operators should be marked as noexcept .

When used with standard containers this will enable certain optimizations. This is because if the move is noexcept then certain operations can be guaranteed to work and thus provide the strong exception guarantee.

Leak in assignment

Note: Your current assignment potentially leaks. If this currently has a pointer assigned then you overwrite it without freeing.

Checking for this pessimization

Yes you do need to make it work when there is self assignment. But in real code the self assignment happens so infrequently that this test becomes a pessimization on the normal case (same applies for copy operation). There have been studies on this (please somebody post a link; I have lost mine and would like to add it back to my notes).

The standard way of implementing move is via swap. Just like Copy is normally implemented by Copy and Swap.

Using the swap technique also delays the calling of the destructor on the pointer for the current object. Which means that it can potentially be re-used. But if it is going out of scope the unique_ptr destructor will correctly destroy it.

Good first try but still lots of issues.

Please read the article I wrote on unique_ptr and shared_ptr for lots more things you should implement.

Smart-Pointer - Unique Pointer Smart-Pointer - Shared Pointer Smart-Pointer - Constructors

Some things you missed:

• Constructor with nullptr
• Constructor from derived type
• Casting to bool
• Checking for empty
• Guaranteeing delete on construction failure.
• Implicit construction issues
• Dereferencing

When you have read all three articles then the bare bones unique_ptr looks like this:

Test to make sure it compiles:

• \$\begingroup\$ What would be a safer way of constructing the unique_ptr from a pointer of type T? \$\endgroup\$ –  dav Commented Jul 20, 2018 at 23:18
• \$\begingroup\$ @DavidTran. Please look at the standard version and its interface. \$\endgroup\$ –  Loki Astari Commented Jul 22, 2018 at 6:13
• \$\begingroup\$ @Mashpoe there is no need to check if a pointer is null before calling delete. \$\endgroup\$ –  Loki Astari Commented Jan 14, 2019 at 17:02
• \$\begingroup\$ @U62 Compiles fine for me. In both cases they are converted to the correct type before the swap. It will only fail to compile if the class U is not derived from the class T which is exactly what it is supposed to do . \$\endgroup\$ –  Loki Astari Commented Apr 5, 2019 at 16:51
• 1 \$\begingroup\$ @user4893106 much of that constructor ridiculousness... : For an average class zero. In most situations the default implementation works out of the box with no need to do anything. For complex classes like this case there is usually a standard implementation already available in std:: . Not sure what "simple ops only" means. \$\endgroup\$ –  Loki Astari Commented Sep 3, 2020 at 18:06

Yes, have good formatting

I have the same thought present in Martin York' answer:

Yes, you forgot to add T, and T[], and the following features:

type* release();

void reset(type* item);

void swap(unique_ptr &other);

type* get();

operator->;

operator[];

Yes, you must force the receiving of types strictly to be pointers

Copy assignment operator

This is redundant, this part is not necessary as this operator will never be called taking into account that the motion constructor exists and the copy constructor is disabled (= delete).

Template only typename T

You must accept both types T, and T[], ie: array or not.

Constructing from object

Verify in move assignment operator.

Before _ptr =, you need to check if this->ptr is initialized, if yes delete ptr before assign.

This above code is incorrect, this is pointer and uptr is reference, you need to add &other to verify successfully

Note: std::move in uptr._ptr is irrelevant.

Example code

• \$\begingroup\$ I certainly didn't plagiarize the answer, I adopted the same html design pattern to create my answer, but the content is different, obviously I forgot to put the proper reference to the two contents I mentioned the previous answer, being them #NoExcept and #It follow common C++, as my way of thinking is similar. Anyway, in these specific topics I added the reference to the original answer (@Martin York), thanks for the warning. \$\endgroup\$ –  Lucas Paixão Commented Sep 22, 2021 at 19:02

Your Answer

Sign up or log in, post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged c++ c++11 reinventing-the-wheel pointers or ask your own question .

• The Overflow Blog
• Where developers feel AI coding tools are working—and where they’re missing...
• He sold his first company for billions. Now he’s building a better developer...
• Featured on Meta
• User activation: Learnings and opportunities
• Preventing unauthorized automated access to the network

Hot Network Questions

• Are there individual protons and neutrons in a nucleus?
• Does a ball fit in a pipe if they are exactly the same diameter?
• Could a Project like Orion be built today with non nuclear weapons?
• What is the smallest interval between two palindromic times on a 24-hour digital clock?
• \element and \lowercase or \MakeLowercase not working together
• What are these Ports on Multimeter PCB & What Protocol are they Using?
• What made scientists think that chemistry is reducible to physics and when did that happen?
• Can we divide the story points across team members?
• Player sprite becomes smaller during attack animation (Java)
• I need a temporary hoist and track system to lift a dead chest freezer up through a tight stairwell
• How do I link a heading containing spaces in Markdown?
• Is there any language which distinguishes between “un” as in “not” and “un” as in “inverse”?
• In the absence of an agreement addressing the issue, is there any law giving a university copyright in an undergraduate student's class paper?
• Is p→p a theorem in intuitionistic logic?
• Tikz template for organization chart
• Does legislation on transgender healthcare affect medical researchers?
• cURL in bash script reads $HOME as /root/
• Undamaged tire repeatedly deflating
• How important exactly is the Base Attack Bonus?
• 2000s creepy independant film with a voice-over of a radio host giving bad self-help advice
• The answer is not ___
• Can a floppy disk be wiped securely using the Windows format command with the passes-parameter?
• Does the Rogue's Evasion cost a reaction?
• Could you suffocate someone to death with a big enough standing wave?

• C++ Data Types
• C++ Input/Output
• C++ Pointers
• C++ Interview Questions
• C++ Programs
• C++ Cheatsheet
• C++ Projects
• C++ Exception Handling
• C++ Memory Management

Unique_ptr in C++

std::unique_ptr is a smart pointer introduced in C++11. It automatically manages the dynamically allocated resources on the heap. Smart pointers are just wrappers around regular old pointers that help you prevent widespread bugs. Namely, forgetting to delete a pointer and causing a memory leak or accidentally deleting a pointer twice or in the wrong way. They can be used in a similar way to standard pointers. They automate some of the manual processes that cause common bugs.

Prerequisites: Pointer in C++ , Smart Pointers in C++.

• unique_ptr<A>: It specifies the type of the std::unique_ptr. In this case- an object of type A.
• new A : An object of type A is dynamically allocated on the heap using the new operator.
• ptr1 : This is the name of the std::unique_ptr variable.

What happens when unique_ptr is used?

When we write unique_ptr<A> ptr1 (new A), memory is allocated on the heap for an instance of datatype A. ptr1 is initialized and points to newly created A object. Here, ptr1 is the only owner of the newly created object A and it manages this object’s lifetime. This means that when ptr1 is reset or goes out of scope, memory is automatically deallocated and A’s object is destroyed.

When to use unique_ptr?

When ownership of resource is required. When we want single or exclusive ownership of a resource, then we should go for unique pointers. Only one unique pointer can point to one resource. So, one unique pointer cannot be copied to another. Also, it facilitates automatic cleanup when dynamically allocated objects go out of scope and helps preventing memory leaks.

Note: We need to use the <memory> header file for using these smart pointers.

Examples of Unique_ptr

Lets create a structure A and it will have a method named printA to display some text. Then in the main section, let’s create a unique pointer that will point to the structure A. So at this point, we have an instance of structure A and p1 holds the pointer to that.

Now let’s create another pointer p2 and we will try to copy the pointer p1 using the assignment operator(=).

The above code will give compile time error as we cannot assign pointer p2 to p1 in case of unique pointers. We have to use the move semantics for such purpose as shown below.

Managing object of type A using move semantics.

Note once the address in pointer p1 is copied to pointer p2, the pointer p1’s address becomes NULL(0) and the address stored by p2 is now the same as the address stored by p1 showing that the address in p1 has been transferred to the pointer p2 using the move semantics.

Similar Reads

• Geeks Premier League
• Geeks Premier League 2023

Please Login to comment...

• How to Underline in Discord
• How to Block Someone on Discord
• How to Report Someone on Discord
• How to add Bots to Discord Servers
• GeeksforGeeks Practice - Leading Online Coding Platform

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

25.1 — Pointers and references to the base class of derived objects

• Skip to right header navigation
• Skip to main content
• Skip to secondary navigation
• Skip to primary sidebar

Learn how to easily plan your dream trip to Florida!

15 Best Restaurants In Saint Petersburg You Must Try

October 6, 2020 //  by  Florida Trippers

Famous for its award-winning beaches, did you know the restaurants in Saint Petersburg have been getting the kind of same attention? Because of its culinary excellence, Saint Petersburg has been raking in mouthwatering reviews, making it a force to behold.

The arts scene has already been raising the bar in the area, so it’s no surprise that the dining scene has done the same thing. Experiencing somewhat of a cultural renaissance, restaurants in Saint Petersburg have been slowly gaining national attention.

USA Today ranked St. Pete as one of “five underrated food cities on the East Coast.” Local chef Jeremy Duclut won the Champion title of the Food Network show “Chopped.” The Mill in downtown was named Best New Restaurant in Florida by Florida Trend Magazine!

The local culinary staples unique to Saint Petersburg are what make foodies keep coming back for more. Remember, this is where the Cuban Sandwich was invented. You won’t taste better Gulf seafood here, like shucked and fried oysters. Some restaurants will even cook the fish you just caught!

No matter what you’re in the mood for, restaurants in Saint Petersburg are ready to fulfill that craving. From Spanish and Italian to Japanese and New American, Saint Petersburg has it all.

Is your mouth watering yet? Picking just one place can be daunting. So if you’re having trouble choosing where to eat in Saint Petersburg, we’ve picked our 15 favorite hotspots!

Stillwaters Tavern

Located on scenic Beach Drive with idyllic waterfront views, bask in the lighthearted ambiance of Stillwaters! With great views of the new Pier, sparkling waters of the Bay, and the glamour of the city, Stillwaters is one of the best restaurants in Saint Petersburg.

Within walking distance of the Dali Museum and the Chihuly Exhibit, Stillwaters sits in the middle of the best of the St. Pete’s attractions ! Here you’ll find a modern American eatery with some of the most creative food, married perfectly with old-world flavors.

Stillwaters collaborates with local artisans and farmers to serve the best seasonal and locally sourced dishes with a twist. Start with the Apple-Bourbon Smoked St. Louis Ribs. The twist can be found in the fresh red cabbage, green apple, and carraway slaw on the side!

For entrees, try American favorites like Gulf Shrimp & Grits, the Cheesesteak French Dip, and the freshest Mahi Sandwich! Make sure to try the Tavern Sausages, all made in house with knockwurst, kielbasa, and lamb merguez!

At the heart of any tavern is its beer selection! Among the collection here you’ll find 20 beers, many of which are regionally crafted. You can also choose from an extensive wine and cocktail list. Two house wines and specialty cocktails are even on tap!

You’ll find Stillwaters Tavern at 224 Beach Drive NE. Hours are Monday through Thursday from 11:30 AM – 10 PM, Friday from 11:30 AM – 11 PM, Saturday from 11 AM – 11 PM, and Sunday from 11 AM – 9 PM. Happy Hour is 11 AM – 7 PM!

Bacchus Wine Bistro

A haven for foodies, enjoy the best wine, cheese, raclette, and charcuterie St. Pete has to offer! Named after bacchus, the god of wine, we think he would be proud of the wine and food in Saint Pete.

In a city growing and developing in modernity, Bacchus Wine Bistro remains a staple. Step into an oasis of old-world charm nestled in a bustling cityscape! The French farmhouse decor transports diners to a simpler time, where you can focus on what matters: good friends and good wine.

If this all sounds overwhelming, the knowledgable staff will guide you through a tastefully appointed menu. Choose from farm-fresh salads, sandwiches, and flatbreads. Our favorites are the Beet Carpaccio and the Pates, whether they be made from tuna, pork, or liver!

You can’t go to a wine bistro without building your own planche! Go down the savory route and choose from charcuteries like foie gras, cured sausages, salt-cured meats, and of course, well aged cheeses.

For a dessert planche, choose from a variety of truffles: sea salt caramel, raspberry, buttercreme, and more! Pair with specialties like the Belgian chocolate-covered Oreos and Chocolate Caramel Pretzels.

No charcuterie experience is complete without wine, so Baccus absolutely delivers! Their Wine Library, guarded by the Vitale Brothers’ Baccus mural, offers 100 selections from France, Italy, Spain, and the United States. Don’t be afraid to ask for help choosing.

Find Bacchus Wine Bistro at 124 2nd Ave NE. Hours are Sunday through Thursday from 11 AM – 10 PM, Friday and Saturday from 11 AM – 11 PM. Happy Hour is 4 PM – 7 PM, every day!

Bella Brava

Since Bella Brava opened their doors in 2005, their main focus has been to bring the hills of Tuscany to the heart of St. Pete. This New World Trattoria serves some of the best food in Saint Pete!

Blending Italian cuisine with the New World urban vibe of Saint Pete, Bella Brava is less formal than a ristorante, but much more upscale than your average Italian joint. Wood stone ovens bring out the Tuscan twist on their menu, fusing classics with New World flair.

Choose between the freshest insalate, house-made pastas, and authentic, wood-fired pizzas. Our favorite dish is the Stuffed Gnocchi in Vodka sauce with roasted tomatoes, mushrooms, and Pecorino romano cheese!

Enjoy your meal in the open dining room or on the European-style patio. With a gigantic horseshoe-shaped bar, kick back and enjoy the longest Happy Hour on Beach Drive. You don’t even have to feel guilty about leaving your furry friend at home: dogs are welcome!

With an expansive wine menu, choose from selections all over the world, with a focus on Italian regional favorites. At the end of your meal, you’ll be saying Bella “Bravo!”

Find Bella Brava on 204 Beach Drive NE. Hours are Monday through Friday from 11:30 AM – 10 PM, Saturday from 11:30 AM – 11 PM, and Sunday from 11:30 AM – 9:30 PM.

Ichicoro Ane

Every foodie has that one restaurant they swear by. That one place they can’t wait to return to even though they just dined there last night. Serving up Japanese culinary magic and an innovative cocktail menu to make spirit geeks weep is one of the best downtown Saint Petersburg restaurants, Ichicoro Ane.

When you first walk in, you’ll see a glimpse of the ramen shop beyond the hostess stand. The dining room, cordoned off by minimalist blonde wood slats transports you to a different world. Just like its counterpart in Tampa, Ichicoro Ane’s simplicity knows exactly what its doing!

Start with the Chashyu Bao, light, airy steamed buns filled with either pork belly, chicken, or smoked beef. Then choose from four kinds of skewers: beef, chicken meatball, or shiitake mushroom or grilled corn for vegetarians.

The main star of the menu, and our favorite, is the Tuna poke. Salivate over large chunks of sushi-grade fish served with gochujang glaze (fermented red chili paste). Scoop it up with shrimp chips as the cucumber, sesame, and green scallions round out the flavors masterfully.

Stewards of the most elegant Japanese libations, the Drinking Den only serves eight cocktails, but each one packs a punch. Try the Black Mage which features activated charcoal amaro with IPA. The Genji Glove masterfully blends white rum with matcha!

Find Ichicoro Ane on 261 1st Ave S from Tuesday through Thursday from 3 – 10 PM, Friday from 3 -11 PM, and Saturday and Sunday from 11 AM – 11 PM. The Drinking Den’s late night hours are Tuesday through Thursday from 10 PM – 12 AM and Friday and Saturday from 11 PM – 1 AM.

Datz is an American gastropub that elevates your average comfort food. Described as “if Willy Wonka owned a restaurant,” Datz is no doubt one of the best restaurants in Saint Petersburg.

Even Food Network has profiled Datz as one of the best restaurants in Tamps responsible for championing the gastronomic revival. Datz also offers vegetarian, vegan, and gluten-free options.

Datz  features a highly eclectic menu that puts original spins on your favorite American classics. You’ll first receive a complimentary popcorn basket! Afterward, try the Chicken-skin Tacos, or Bacon and Jalapeno Mac and Cheese with Sriracha aioli. Our favorite is the Short Rib Sloppy Joes.

Afterward, grab an unforgettable Bacon Bloody Mary. Then, head next door to Dough. The sister-bakery offers the craziest sweets like Creme Brulee and Froot Loop Donuts, homemade gelato, and delicate French Macarons.

Datz can be found on 180 Central Ave. Hours are Monday through Thursday 7 AM – 10 PM, Fridays 7 AM -11 PM, Saturday 8:30 AM -11 PM, and Sunday 8:30 – 9 PM.

Spinner’s Rooftop Revolving Bistro

For the most romantic date night , take your significant other to Spinner’s Rooftop Revolving Bistro! On the 12th floor of the Grand Plaza Resort Hotel and Spa , you’ll find the only revolving restaurant in Florida!

In the most romantic ambiance, enjoy the best of St. Pete fine dining. At Spinner’s you’ll truly “elevate” your experience, creating memories you’ll be talking about long after dessert is served.

Spinner’s actually revolves a full 360 degrees. Don’t worry, it doesn’t move too fast! As you slowly rotate, you’ll appreciate an unparalleled bird’s eye view of St. Pete lit up at night, the Bay, and the beautiful beaches of St. Pete .

Start with the Shrimp Ceviche made with fresh mangoes and chiles or Blackened Scallops with caramel ginger-preserved prickly pear glaze. Move on to an entree menu with the best of Florida seafood and premium-aged steaks. Our favorites are the Spaghetti Squash Primavera and the Soy Lacquered Chilean Seabass.

Finish the evening with a tropical cocktail menu, with a sophisticated representation of Florida. Choose between drinks like the Coconut Mango Mojito, Carribean Rum Punch, or the Signature Spinners 75, the Florida take on the French 75. There’s also a wide variety of wines and champagnes, available both by the glass and the bottle.

Spinner’s Rooftop Revolving Bistro can be found on the 12th floor of the Grand Plaza Resort Hotel at 5250 Gulf Blvd. Dine on Wednesdays through Sundays from 5 – 10 PM.

One of the newest additions to the downtown Saint Petersburg restaurant scene is The Mill. A must-try restaurant, The Mill specializes in New American food with a Southern spin.

Since opening in 2015, The Mill has already raked in multiple prestigious awards like Best New Restaurant in Florida by Florida Trend Magazine. Chef Ted Dorsey also took home the coveted Best Chef Award in Creative Loafing’s Best of the Bay and the SPDNA Sunshine Award in 2016 for Best Fine Dining.

Start with classic Southern staples like Fried Green Tomatoes, Apple Fritters, and Biscuits & Gravy. Share a plate off the slider menu with options like Grilled Cheese, Pickled Peach BBQ Grilled Chicken Club, or the Mill Sliders with bacon, pimento cheese, and caramelized onion aioli.

Make sure you’ve saved room for the main event. The Sausage and Waffle Benny is topped with fried green tomatoes and a gumbo file hollandaise! The iconic Croque Madame has gruyere cheese, caramelized onions, and mustard aioli on challah.

A festive and whimsical cocktail list includes the Post H20 Malone, el Duderino, and the Carrot & Schtick. Our favorite is their take on the Old Fashioned with uses orange and chocolate bitters.

Dine at the Mill on 200 Central Avenue on Tuesdays through Thursdays from 11 AM – 9 PM, Fridays from 11 AM – 10 PM, Saturday from 10 AM – 10 PM, and Sunday from 10 AM – 9 PM. Try weekend brunch on the weekends from 10 AM – 4 PM!

Boardwalk Grill

In the early 2000s, Stuart Saltzman brought his twenty years of experience in bar management to Clearwater Beach. Seeking to elevate the sports bar game in St. Pete, he did just that at the Boardwalk Grill at John’s Pass Boardwalk!

A recreation of the Jersey Shore right here in Clearwater Beach, Boardwalk Grill is glitzy, yet laid-back. Everybody enjoys the feel of a boardwalk, from the fun to the games, and especially the food. Like a museum , the inside borrows elements from all over the country, not just the Jersey Shore.

Saltzman brought two secret recipes down with him from the Garden State: the hot wings and the Grouper Sandwich. They’re the real deal, each scoring “best of” awards in New Jersey. Don’t forget the unbeatable Lobster Rolls, Fish Tacos, and juiciest burgers on the beach!

After you’ve eaten, hang out on the patio for the cheapest beer on the boardwalk with stunning Gulf views. The full bar features 16 draft and 25 bottled beers with more than a dozen wines. Pull up a chair, you might even get a chance to meet Stu!

Check out the Boardwalk Grill on 204 John’s Pass Boardwalk every day from 10 AM – 9 PM.

Hurricane Seafood Restaurant

Don’t be fooled by the ominous name, the Hurricane isn’t so much a catostrophic weather event. It is a force of nature delivering some of the best nightlife and food in Saint Pete Beach! Just like the storm, the Hurricane is hard to miss: look for the bright green building on the corner.

42 years after its opening, the Hurricane has remained a popular destination for both locals and tourists from all over the world! Still operated by the founders, the Falkenstein Family serves the freshest Gulf seafood in a casual island setting.

The Hurricane offers three floors of dining space, each with its own menu. The ground level features the original Hurricane menu, including “Mom’s 1945 Crabcake Melt.” On the beachfront Level 2, enjoy pork potstickers, peel and eat shrimp, and a mahi fish spread, all while taking in million-dollar views.

On the Rooftop South Deck Bar, share the Wing Ding Basket or Landshark Beer-Battered Shrimp Basket. If you still have room in your stomach, have all-day breakfast with a massive two-egg sandwich with your choice of meat, bread, and cheese.

Brave the Hurricane at 809 Gulf Way on Sundays through Thursdays from 11 AM – 9:30 PM, and Fridays and Saturdays from 11 AM – 10 PM.

Jubilee’s BBQ

Formerly known as Rib City, this locally-beloved franchise rebranded itself in 2019 for a more festive name! Now, Jubilee’s BBQ is still the original location for the eponymous Florida chain. One of the best restaurants in Saint Petersburg, you won’t find juicier and smokier ribs anywhere else in the Bay area!

At Jubilee’s the meat falls right off the bone, its so tender! In a homey, warm atmosphere, don’t be afraid to get down and dirty with this barbecue! Don’t worry, Jubilee’s BBQ provides wipes when you’re finished.

Jubilee’s full menu features barbecued meats paired with specialized sauces. Choose from side dishes including made-from-scratch baked beans and coleslaw, as well as collard greens, corn pudding, and macaroni and cheese.

Jubilee’s BBQ also serves locally crafted Saint Pete favorite 3 Daughters Brewery Beer. Make sure you’ve saved room for a frosty pint to wash down your meal!

Check out Jubilee’s BBQ, open daily for lunch and dinner from Monday through Thursday from 11 AM – 8:30 PM, Friday and Saturday from 11 AM – 9 PM, and Sunday from 11 AM – 8:30 PM.

Sea Porch Cafe

Locals know the historic pink building in St. Pete Beach to be the Don Cesar, one of the best resort spas in Florida . Just inside, you’ll find the Sea Porch Cafe, one of the best restaurants in Saint Petersburg.

The Don Cesar is known for its extravagance, and their restaurants are no exception. At the Sea Porch Cafe, you’ll find fresh Gulf seafood and local comfort foods in this seaside dining haven. Perfect for a relaxed breakfast, lunch, or dinner, choose between comfortable indoor seating, or outdoor dining with the smell of the coastal breeze.

If a regular meal isn’t enough, host a private event at Gatsby’s Private Dining room. Seat up to 30 guests in this elegant space directly above the Sea Porch with stunning views of the prettiest beaches in Florida . Choose from the Sea Porch Cafe’s menu.

To really feel swanky, gather at the Pink Palace for a Sunday Funday at the Sunday Champagne Brunch. From 11 AM – 3 PM, enjoy made-to-order omelets, custom carving stations, fresh salads, and delectable desserts. Then meet friends at the Rowe bar for a classic mint julep or hand-crafted spiked lemonade!

Pamper yourself at the Sea Porch Cafe at the Don Cesar at 3400 Gulf Blvd, open every day from 7 AM – 10 PM.

Locals know that the St. Petersburg Pier was under construction for what felt like forever. Today a sleek, modern design reflects the city’s bustling development, including one of the best new restaurants in Saint Petersburg, Teak.

With a nautical-themed menu crafted by the top chefs in the Bay Area, you can immerse yourself in the most serene setting atop the Pier. Bask in the tranquil ambiance complete with 360 degree views of the entire bay.

Start your elevated culinary journey with Conch Beignets, Boiled-Peanut Hummus, and Shucked Oysters, all inspired by Florida classics you can find at seafood shacks and stands on the side of the road.

For heavier entrees, you’ll find only the best of Florida surf and turf. Choose from Florida Yard Bird, roasted in jezebel sauce, or the 12 oz NY Strip! For a bit of everything, get the Summer Rental Platter with popcorn coconut shrimp, mahi bites, fried oysters, and more!

Experience Teak on the 4th floor of the new St. Pete Pier at 800 2nd Ave NE from Sunday through Thursday from 11 AM – 10 PM, and Friday and Saturday from 11 AM – 11 PM.

Brick and Mortar

A newer edition to the St. Pete dining scene, Brick and Mortar got its name from its journey to existence! It’s rare for caterers to take the plunge into opening a full restaurant, but in April of 2015, that’s just what happened.

Brick and Mortar fills an unusual niche in St. Pete. It’s upscale, but not expensive, inventive, but not gimmicky. The menu features Indonesian and Spanish touches in an interesting twist on New American, making it some of the best food in Saint Pete.

Our favorite appetizer is the Ahi Tartare with avocado, ponzu, and sesame with shrimp crackers for scooping. If that seems intimidating, don’t worry. You’ll also find homey and even kid-friendly meals.

Try the Slow-braised Oxtail or the Crispy-skinned Airline Chicken Breast with carrots and crispy fingerling potatoes!

The ambitious beer and wine list mixes both local and nationally known craft beers on draft and in bottles. Be delighted by the choices of old and new world wines available by the glass and bottle!

Check out Brick and Mortar on 539 Central Avenue on Tuesdays from 5 – 9 PM, Wednesday and Thursday from 5 – 10 PM, Friday from 4:30 – 11 PM, and Saturday from 4:30 – 11 PM.

Sure, you’ve grabbed a quick meal before or after a flight in a crowded airport. Can you say that you’ve gone to an airport just for a meal? Inside the Albert Whitted Airport, you’ll find this hidden gem , one of the best restaurants in Saint Petersburg.

The Hangar describes itself as not only a restaurant but a flight lounge. In downtown St. Pete, the Hangar hides in an airport, but its location affords diners an unbeatable view. Not only do you have a bird’s eye view of the bay, you’ll be delighted seeing plane and helicopter activity on the tarmac!

You won’t find the usual airport fare here. A true fine-dining experience, you’ll be wowed with exceptional pasta dishes, gigantic sandwiches, and small plates you won’t want to share!

Stop by on Friday Nights to hear the smooth stylings of the Dwayne White Trio. Kick back and enjoy the smooth jazz that cements the elegant ambiance.

Because the Hangar is in an airport, of course they serve breakfast! The award-winning menu serves eggs cooked in endless ways: benedict, florentine, southern benedict, in omelettes, and even the Wheels Up Bowl. Don’t forget jumbo waffles and pancakes!

Land at the Hangar inside the Alfred Whitted Airport at 540 1st Street S from 8 AM – 11 PM daily!

Inside the Ponce de Leon Hotel, you’ll find a Spanish chain outpost that serves up the best tapas in the Bay area. The closest thing to visiting Spain, Ceviche serves the best authentic Spanish food in Saint Pete.

If you’ve ever been to Barcelona, you’ll be familiar with the locals’ laid-back and delicious approach to life. As you gather over tapas, or small plates, you’ll taste the magic of the Iberian Coast without having to hop across the pond.

Ceviche’s authentic tapas menu is expansive and caters to all tastes. Start with the house ceviche, a perfect marriage of shrimp, scallops, and squid. You can’t miss the Pollo al Jerez either, chicken in pesto and sherry cream.

Vegetarians will also appreciate the Baba Ganoush, starring meaty eggplant, or the Hummus Dip made with garbanzo beans and tahini. Don’t forget the Patatas Bravas, potatoes in a spicy aioli!

Get a taste of Spain on 10 Beach Drive on Monday through Thursday from 12 – 10 PM, Friday and Saturday from 11 – 11 PM, and Sunday from 12 – 9 PM.

• Quick Facts
• Sights & Attractions
• Tsarskoe Selo
• Oranienbaum
• Foreign St. Petersburg
• Restaurants & Bars
• Accommodation Guide
• St. Petersburg Hotels
• Serviced Apartments
• Bed and Breakfasts
• Private & Group Transfers
• Airport Transfers
• Concierge Service
• Russian Visa Guide
• Request Visa Support
• Walking Tours
• River Entertainment
• Public Transportation
• Travel Cards
• Essential Shopping Selection
• Business Directory
• Photo Gallery
• Video Gallery
• 360° Panoramas
• Moscow Hotels
• Moscow.Info

Squares of St. Petersburg

St. Petersburg's public squares, of which Palace Square in front of the Winter Palace is undoubtedly the most famous, were designed on the grand scale, many by the Italian-born master of high neoclassicism Carlo Rossi. Punctuating the architectural oration of St. Petersburg's magnificent avenues and embankments like dramatic rhetorical pauses, these spaces impress with their vastness and their decorum, offering splendid vistas onto the columned facades of the city's most striking buildings.

We can help you make the right choice from hundreds of St. Petersburg hotels and hostels.

Live like a local in self-catering apartments at convenient locations in St. Petersburg.

Comprehensive solutions for those who relocate to St. Petersburg to live, work or study.

Maximize your time in St. Petersburg with tours expertly tailored to your interests.

Get around in comfort with a chauffeured car or van to suit your budget and requirements.

Book a comfortable, well-maintained bus or a van with professional driver for your group.

Navigate St. Petersburg’s dining scene and find restaurants to remember.

Need tickets for the Mariinsky, the Hermitage, a football game or any event? We can help.

Get our help and advice choosing services and options to plan a prefect train journey.

Let our meeting and events experts help you organize a superb event in St. Petersburg.

We can find you a suitable interpreter for your negotiations, research or other needs.

Get translations for all purposes from recommended professional translators.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

assignment operator error in unique pointer

I tried to use unique_ptr in c++ in a singelton pattern instead of raw pointer. when I want to assign a unique_ptr to another I got an error. I tried to use std::move to assign but it did not work. the code is as follow:

and the error I got is

and another question is if nullptr can be used for unique_ptr .

• 3 make_unique<ClientDB> needs to be called . make_unique<ClientDB>() . Mind you, you approach is still broken. You can't return a unique_ptr while holding on to the ownership of the object. –  StoryTeller - Unslander Monica Commented Jan 27, 2019 at 7:19
• @StoryTeller you're right. this is another error I got `error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = ClientDB; _Dp = std::default_delete<ClientDB>]’ return theDB;' –  user10875974 Commented Jan 27, 2019 at 7:25
• 1 Yeah, that's the copy constructor (which doesn't exist because unique_ptr wants to be ... well, unique). –  melpomene Commented Jan 27, 2019 at 7:30
• Basically, return theDB is trying to create a copy of a unique_ptr , which is forbidden. You may return a reference unique_ptr& or the raw pointer managed by the unique_ptr : return theDB.get() . –  ChronoTrigger Commented Jan 27, 2019 at 8:04
• Don't use Singleton, and if you do, don't use unique_ptr for it. See stackoverflow.com/a/1008289/2466431 –  JVApen Commented Jan 27, 2019 at 11:47

Finally by help of my teacher, I can solve the problem. there is some points should be considered.

1- for unique_ptr assignment, std::move:: should be used.

2- make_unique has no access to the private constructor, the constructor should be called explicitly: theDB = unique_ptr<ClientDB>(new ClientDB());

3-The unique-ptr must be initialized outside the class: unique_ptr<ClientDB> ClientDB::theDB;

4- Three unique pointers in main for the same object can not be used, only one is allowed for uniqueness. references to unique_ptr should be used instead: unique_ptr<ClientDB>& db1=ClientDB::getInstance();

and finally the code should be like this

• A reference to unique_ptr is usually pointless. The getInstance should return either a raw pointer ClientDB* or a reference ClientDB& , since the caller is not involved at all in managing the lifetime of the object. Unless you want code to be able to steal the object by unique_ptr<ClientDB> mine = std::move(ClientDB::getInstance()); and make it not really a singleton! –  aschepler Commented Feb 1, 2019 at 12:10

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

• The Overflow Blog
• Where developers feel AI coding tools are working—and where they’re missing...
• He sold his first company for billions. Now he’s building a better developer...
• Featured on Meta
• User activation: Learnings and opportunities
• Preventing unauthorized automated access to the network
• Should low-scoring meta questions no longer be hidden on the Meta.SO home...
• Announcing the new Staging Ground Reviewer Stats Widget

Hot Network Questions

• Can ATmega328P microcontroller work at 3.3 V with 8 MHz oscillator
• Do all languages distinguish between persons and non-persons?
• is it okay to mock a database when writing unit test?
• Solving a "One Away.." connections group with nine guesses
• How to push 10-ft long 4" PVC pipe into 90-deg Elbow Hub?
• Is the Star Trek TNG episode Aquiel inspired by The Thing?
• Short story about a space traveller on a planet of people, each immensely talented
• cURL in bash script reads $HOME as /root/
• Is “No Time To Die” the first Bond film to feature children?
• Does the Rogue's Evasion cost a reaction?
• How is the universe able to run physics so smoothly?
• Is BitLocker susceptible to any known attacks other than bruteforcing when used with a very strong passphrase and no TPM?
• Extract basil seeds from dry husk
• What are these Ports on Multimeter PCB & What Protocol are they Using?
• How long has given package been deferred due to phasing?
• Is a private third party allowed to take things to court?
• An everyday expression for "to dilute something with two/three/four/etc. times its volume of water"
• Could a Project like Orion be built today with non nuclear weapons?
• Sticky goo making it hard to open and close the main 200amp breaker
• Print 4 billion if statements
• Why would an escrow/title company not accept ACH payments?
• What is the simplest formula for calculating the circumference of a circle?
• I want a smooth orthogonalization process
• Pulling myself up with a pulley attached to myself