C++: recursive_directory_Iterator. two similar using,but in one of them throwing exeption

Code with throwing exeption: **terminate called after throwing an instance of 'std::filesystem::__cxx11::filesystem_error'
what(): filesystem error: cannot increment recursive directory iterator: Invalid argument

#include <iostream>
#include <filesystem>
#include <string>
using namespace std;
using namespace std::filesystem;
void explore(const directory_entry& directory,size_t& counter) {
for(const auto& entry : recursive_directory_iterator{ directory.path() }) {
cout<<"\nREC: "<<entry;
counter++;
}
}
int main(int argc,char* argv[]){
if(argc) cout<<"";
if(argc!=3){
cerr<<"Wrong arguments. Usage app \"PATH\" \"three symbols extension\"\n";
return -1;
}
recursive_directory_iterator di{argv[1]},end;
size_t counter{};
explore(directory_entry{argv[1]},counter);
(counter)? cout<<"\nTotal files in "<<argv[1]<<"with extension *"<<argv[2]<<" is "<<counter<<"\n": cout<<"\nFiles with extension "<<argv[2]<<" not found\n";
}

Code with no exeption throwing:

#include <filesystem>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
using namespace std::filesystem;
struct Attributes {
size_t size_bytes;
size_t n_directories;
size_t n_files;
};
void print_line(const Attributes& attributes, string_view path) {
cout << setw(12) << attributes.size_bytes << setw(6) << attributes.n_files << setw(6) << attributes.n_directories
<< " " << path << "\n";
}
Attributes explore(const directory_entry& directory) {
Attributes attributes{};
for(const auto& entry : recursive_directory_iterator{ directory.path() }) {
cout<<"\nREC: "<<entry;
}
return attributes;
}
int main(int argc, const char** argv) {
if(argc < 2) {
cerr << "Usage: treedir PATH";
return -1;
}
path sys_path{};
std::string args{};
if(argv[1][0]=='-'){
args=argv[1];
sys_path=argv[2];
}
else{
sys_path=argv[1];
}
bool recursive{};
for(auto& val:args){
if(val=='R') recursive=1;
}
cout << "Size         Files  Dirs Name\n";
cout << "------------ ----- ----- ------------\n";
Attributes root_attributes{};
for(const auto& entry : directory_iterator{ sys_path }) {
try {
if(entry.is_directory()) {
if(recursive){
const auto attributes = explore(entry);
print_line(attributes, entry.path().string());
}
root_attributes.n_directories++;
} else {
root_attributes.n_files++;
error_code ec;
root_attributes.size_bytes += entry.file_size(ec);
if(ec)
cerr << "Error reading file size: " << entry.path().string() << endl;
}
} catch(const exception&) {
}
}
print_line(root_attributes, sys_path.string());
}

In first case, when im start traverse from "C:" im getting exeption,but when i use D:\ traversing ok.In second case,traversing is ok for both C:\ and D:.

applying std::filesystem::directory_options by skip_permission_denied is no help.

Any ideas?

In second snippet you mask exceptions by try {} catch on a general type with no action taken.

Try (sorry) this version of function:

void explore(const directory_entry& directory, size_t& counter) {
try {
for (const auto& entry : recursive_directory_iterator{ directory.path() }) {
cout << "\nREC: " << entry.path();
counter++;
}
}
catch (std::filesystem::filesystem_error e) {
cerr << e.what();
}
}

You'll see what's going on.
In my case

REC: "C:\\$Recycle.Bin"
REC: "C:\\$Recycle.Bin\\S-1-5-18"recursive_directory_iterator::operator++: Access is denied.

Program encountered a non-empty recycling bin and was denied the attempt to poke it.

For second case I used a function which would print a diagnostic message before propagating exception further up. Note, it might be not a good idea to use exceptions as a control flow. Where possible, it's prefereable to use function return values.

Attributes explore(const directory_entry& directory, bool verbose) {
Attributes attributes{};
try {
for (const auto& entry : recursive_directory_iterator{ directory.path(),std::filesystem::directory_options::skip_permission_denied }) {
if (verbose)
cout << "\nREC: " << entry.path();
}
}
catch (std::filesystem::filesystem_error& e) {
cerr << directory.path() << ":" << e.what();
throw e;
}
return attributes;
}

and had liberty to add spam-control flag:

bool recursive{}, verbose{};
for (auto& val : args) {
if (val == 'R') recursive = true;
if (val == 'v') verbose = true;
}

To call explore():

			if (recursive) {
const auto attributes = explore(entry, verbose);

Reducing your two versions to the essentials, you are comparing this:

// A
size_t N = 100;
for (size_t i=0; i<N; ++i) {
might_throw();
}

with

// B
size_t N = 100;
for (size_t i=0; i<N; ++i) {
try {
might_throw();
} catch(const exception& e) {
// do nothing
}
}

In the first, when might_throw throws an exception then the exception travels up in the call stack and because nowhere you catch the exception the program will terminate. When an exception is thrown in the first iterations, then other iterations will not be executed.

In the second, when might_throw throws an exception then the exception is caught by the try-catch. You don't do anything with the exception and then the next iteration is executed. When an exception is thrown in the first iteration, then the other iterations are still executed.

You can replace //do nothing with eg std::cout << e.what() << "\n"; to produce some output in case of an exception. Most likely you will see the same exceptions being thrown in both variants of your code (except that the first will terminate after the first).