Как лучше передавать аргумент в функцию - по ссылке или по указателю?

void change(data& target);
void view(const data& target);

#include <iostream>
 
struct data { int v = 0; };
 
void view(const data& target)
{
    // error: assignment of member ‘data::v’ in read-only object
    target.v = 33; 
    std::cout << "v = "<< target.v << '\n';
}
 
int main()
{
    std::cout << "Hello, world!\n";
}

int a = 10;
f(a); // f(&a); easy to propose of changing
// is a still equal 10 ?

#include <iostream>
#include <cassert>
 
void f(const int* p)
{
    // если нам нужен качественный, стабильный софт
    // то с указателями, мы вынуждены писать дополнительный проверочный код
    assert(p); 
 
    // а так же подумать о сопутствующем падении производительности
    // если нам нужна отказоустойчивость
    if(!p)
        throw std::runtime_error("expected valid pointer");
    
    std::cout<<"read-only: " << *p << std::endl; 
}
 
void b(int* p)
{
    assert(p);
    std::cout<<"before: "<< *p <<'\n'; 
    *p = 33;
    std::cout<<"change: " << *p << '\n'; 
}
 
int main()
{
    std::cout << "Hello, world!\n";
   
    int a = 10;
 
    // как глядя на одно лишь использование
    // и не зная прототипов,
    // вы определите какая из функций меняет значение, а какая нет?
    f(&a);
    b(&a);
}

#include <iostream>
#include <cassert>
 
void change(int*& p ) //<--- воздействуем на оригинальный указатель
{      // а не на копию
    delete p;
    p = new int(2);
    assert(p);
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    int* p = new int(1);
    
    assert(p);
    
    std::cout << "value = "<< *p << '\n';
    change(p);
    
    assert(p);
    std::cout << "value = "<< *p << '\n';
}

//Title of this code
//gcc 4.9.2
 
#include <stdio.h>
#include <assert.h>
 
 
void change(int** p )
{
    assert(p);
    assert(*p);
 
    free(*p);
    realloc (*p, sizeof(int)); 
    assert(p);
    **p = 2;
}
 
int main(void)
{
    printf("Hello, world!\n");
    
    int* p = malloc(sizeof(int));
    *p = 1;
        
    assert(p);    
    printf("value = %d \n", *p);
    
    change(&p);
    
    assert(p);
    printf("value = %d \n", *p);
    
    return 0;
}

// псевдокод
struct child
{
    child(parent& p)  //<--- принимает по ссылке,
        : m_parent(p)   // потому что ожидает реального
   {}            // валидного папочку
 
    ...
 
    parent& m_parent; //<--- ребенок гарантирует, 
      // что никогда  не поменяет своего родителя
 
};

// псевдокод
struct child
{
    child(parent& p)  //<--- ожидает что родитель - валидный объект
        : m_parent(&p)      // поэтому принимает по ссылке
   {}
 
   ...
 
    parent* m_parent; //<--- ребенок дает понять,
      // что не только может поменять родителя
      // но и вовсе остаться сиротой
};

void foo(const ClassType obj)

//Title of this code
//g++  4.9.2
 
#include <iostream>
 
struct example{};
 
void foo(const example);
void bar(example);
 
int main()
{
    std::cout << "Hello, world!\n";
    
    typedef decltype( &foo )
        foo_t;
    
    typedef decltype( &bar )
        bar_t;
    
    const bool same = std::is_same<foo_t, bar_t>::value;
    
    std::cout <<"is same types? " 
        << (same ? "yes": "no" ) 
        << '\n';
}