Использование ссылок и обычных имен переменных

#include <iostream>
 
void foo(const std::string & s)
{
    //do smth
}
 
int main()
{
    foo("ololo");
    
    std::cout << "Hello, world!\n";
}

void foo(char * str){
cout<<str<<endl;
}
 
int main(int argc, char* argv[])
{
    
foo("ololo!");//c-str литерал имеет тип const char[]

void f1(const Some *) {}
void f2(const Some &){}
//...
f1(&Some{});//фигу
f2(Some{});//норм

template<typename F>
void foo(F f)
{
   const auto &r = f();//не важно, может ли возвращаемый объект перемещаться/копироваться в данном контексте
   r.action1();
   r.action2();
}

//g++  5.4.0
 
#include <iostream>
 
 
#define GENERATE_BODY(name) name() { std::cout << __PRETTY_FUNCTION__ << std::endl; }\
name(const name &) { std::cout << __PRETTY_FUNCTION__ << std::endl; }\
virtual ~name() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
 
 
 
struct Base
{
    GENERATE_BODY(Base)
    void action() const {
        std::cout << "Base::action()" << std::endl;
    }
    virtual void action_v() const {
        std::cout << "Base::action_v()" << std::endl;
    }
};
 
 
 
 
 
 
template<typename F>
void foo_with_reference(F f)
{
    const Base &r{f()};//Нет преобразования (кому нужно, может сам дописать для учета const и тому подобного)
    r.action();//Работаем строго с Base
    r.action_v();//Виртуальность работает
}
 
 
template<typename F>
void foo_without_reference(F f)
{
    Base r{f()};//Получится преобразование, если f возвращает объект-наследник Base.
    r.action();//Это уже другой объект, никак не связанный с тем, который вернула f
    r.action_v();//"Пропала виртуальность". Печалька.
}
 
 
template<typename F>
void foo_with_auto(F f)
{
    auto r{f()};//Не факт, что там Base. Обязательно в наследнике должен быть доступен конструктор копирования/перемещения. Класс не должен быть абстрактным.
    r.action();//Если f вернула наследника Base, то уже логика начальной функции нарушена.
    r.action_v();//Норм.
}
 
 
 
 
struct Derived: Base
{
    GENERATE_BODY(Derived)
    void action() const {
        std::cout << "Derived::action()" << std::endl;
    }
    void action_v() const override {
        std::cout << "Derived::action_v()" << std::endl;
    }
};
 
 
struct AbstractDerived: Base
{
    GENERATE_BODY(AbstractDerived)
    void action() const {
        std::cout << "AbstractDerived::action()" << std::endl;
    }
    void action_v() const override {
        std::cout << "AbstractDerived::action_v()" << std::endl;
    }
    virtual void action_pure_v() const = 0;
};
 
struct NonAbstract: AbstractDerived
{
    GENERATE_BODY(NonAbstract)
    void action_pure_v() const override {
        std::cout << "NonAbstract::action_v()" << std::endl;
    }
};
 
 
 
 
 
Derived create_derived()
{
    return {};
}
 
 
AbstractDerived &create_non_abstract()
{
    static NonAbstract obj;
    return obj;
}
 
 
 
 
int main()
{
    //create_non_abstract();//Чтобы создался статический объект
    std::cout << "\nwithout reference:" << std::endl;
    foo_without_reference(create_derived);
    //foo_without_reference(create_non_abstract);
    std::cout << "\nwith reference:" << std::endl;
    foo_with_reference(create_derived);
    //foo_with_reference(create_non_abstract);
    std::cout << "\nwith auto:" << std::endl;
    foo_with_auto(create_derived);
    //foo_with_auto(create_non_abstract);
    std::cout << "\nend of main" << std::endl;
}