/tech/ - Technology★

>>1070817 (OP)

Isn't RAII just plain stack scope shit but with extra features? Like real_fin doesn't go out of scope so I don't know what you are expecting.

>>1070817 (OP)

>What's the idiomatic C++11 or 14 way of doing this?

What you've written is a mess. How about first stating what you're actually trying to do?

>>1070827

>What you've written is a mess

What's so hard about reading that? It's just a few lines of a simple test of copying an input stream to stdout.

Basically I want to do this.

int
main(int argc, char **argv)
{
  FILE *fin = stdin;
  if (argc == 2)
    {
      fin = fopen(argv[1], "r");
      if (!fin)
        return 1;
    }
  puts("no stupid std::ifstream class"
          " hanging around on the stack"
           " if I'm only using stdin");
  func_that_doesnt_return_for_a_few_weeks();
  fclose(fin);
  return 0;
}

And I don't want to explicitly free anything.

>>1070829

s/func_that_doesnt_return_for_a_few_weeks();/func_that_doesnt_return_for_a_few_weeks(fin);/

>>1070829

Factoring the operation into a function that takes a reference to the base class type is probably the easiest way to do it.

#include <fstream>
#include <iostream>

void
dump(std::istream& in)
{
    std::cout << "dumping" << std::endl;
    std::cout << in.rdbuf();
    std::cout << std::endl << "done" << std::endl;
}

int
main(int argc, char* argv[])
{
    if (argc == 2) {
        std::ifstream ifs(argv[1]);
        if (!ifs) return 1;
        dump(ifs);
    }
    else {
        dump(std::cin);
    }
    return 0;
}

Use Rust. I would post the Rust version but I can't understand this braindamage that you posted.

C/C++ are such ugly languages.

>>1070859

>too stupid to understand C++

The truth behind Rustfags revealed

>>1070862

>not having learned a language makes you stupid

We will soon live in a world without cnility. You are deprecated and considered harmful.

>>1070864

>We will soon live in a world without c

You can get ahead of the curve by uninstalling your operating system.

>>1070867

This but unironically, everything should run ontop of UEFI

>>1070867

We are currently incrementally rewriting GNU/Linux.

>>1070872

>(((UEFI)))

>>1070862

allow me to help. The OP's intent is to write the C++ version of this code:

:- module lol.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module list, exception.

:- pred dump(input_stream::in, io::di, io::uo) is det.

main(!IO) :-
    io.command_line_arguments(Args, !IO),
    ( Args = [File] ->
        io.open_input(File, Res, !IO),
        (
            Res = ok(Stream)
        ;
            Res = error(E),
            throw(E)
        )
    ;
        Stream = io.stdin_stream
    ),
    dump(Stream, !IO).

dump(S, !IO) :-
    io.read_line_as_string(S, Res, !IO),
    (
        Res = ok(Line),
        io.write_string(Line, !IO),
        dump(S, !IO)
    ;
        Res = eof
    ;
        Res = error(Err),
        throw(Err)
    ).

>>1070859

sudo apt remove rust* libstd-rust* cargo*

sudo apt remove snapd* libsnapd*

sudo apt remove firefox thunderbird

>>1070887

>apt

>reddit spacing

>>1070829

If you really care about the stack size, you could also do this.

#include <fstream>
#include <iostream>
#include <memory>

void
dump(std::istream& in)
{
    std::cout << "dumping" << std::endl;
    std::cout << in.rdbuf();
    std::cout << std::endl << "done" << std::endl;
}

int
main(int argc, char* argv[])
{
    if (argc == 2) {
        std::unique_ptr<std::ifstream> fin{new std::ifstream(argv[1])};
        if (!*fin) return 1;
        dump(*fin);
    }
    else {
        dump(std::cin);
    }
    return 0;
}

Can you not just move real_fin into the if statement?

>>1070890

>a year on and this retarded nigger still thinks the compiler is a dependency for compiled rust code

>>1070887

Don't forget bzip2

https://people.gnome.org/~federico/blog/maintaining-bzip2.html

Anti Rust shills on suicide watch

>>1070907

>rustification

>making software slower on purpose

>>1070832

This looks like the most correct answer. Thanks.

>>1071020

So basically all that refactoring and work produced no discernible advantage. Nice to know.

>>1071061

You're welcome. Keep in mind, while the std::ifstream won't be initialized unless needed, space for the object will still be reserved on the stack in main(). If you really must avoid stack allocation altogether, use this one: >>1070892. (but remember to check for allocation failure before dereferenceing, unlike the example).

if (!fin || !*fin) return 1;

>>1071062

the general idea is that the software is safer and easier to work with, while losing no speed. So you can apply new optimizations in the future, or add on new features, that you would have had to avoid if you'd stuck with C.

The problem with this idea is that Rust is harder to work with than C.

>24 responses, no answer

>the absolute state of /tech/

What are you trying to do OP, simply dump the contents of a textfile?

#include <fstream>
#include <iostream>
#include <string>

int main() {
  std::string filename{"FooBar.txt"}, line{};
  std::ifstream ifs{filename};
  while (std::getline(ifs, line))
    std::cout << line << '\n';
}