Передача C++ ссылкой

Ссылки и указатели тесно связаны между собой. Оба являются способами передачи параметров без копирования значения параметра в стековый фрейм подпрограммы.

Основное различие между ними:

• Указатель p указывает на объект o.
• Ссылка i является объектом o. Другими словами, в псевдониме.

Чтобы еще больше запутать ситуацию, насколько я знаю, реализация компилятора между этими двумя вариантами практически одинакова.

Представьте себе функции Ptr(const T* t) и Ref(const T& t).

int main() { int a; Ptr(&a); Ref(a); }

В Ptr, t будет указывать на местоположение a. Вы можете разыменовать его и получить значение a. Если вы сделаете &t (возьмете адрес t), то получите адрес параметра.

In Ref, t is a. Вы можете использовать a для значения a. Вы можете получить адрес a с помощью &a. Это небольшой синтаксический сахар, который дает вам С++.

Оба языка предоставляют механизм для передачи параметров без копирования. В вашей функции (кстати, декларация не нужна):

template <class T> void utilShow(T elem) { ... }

Каждый раз, когда она вызывается, T будет копироваться. Если T - большой вектор, то копируются все данные в векторе. Это довольно неэффективно. Вы не хотите передавать весь вектор в новый кадр стека, вы хотите сказать: "Эй - новый кадр стека, используйте данные this". Поэтому вы можете передавать по ссылке. Как это выглядит?

template <class T> void utilShow(const T &elem) { ... }

elem - это const, потому что он не изменяется функцией. Она также будет использовать память для elem, которая хранится в вызывающей функции, а не копировать ее в стек.

Опять же, по той же причине (чтобы избежать копирования параметров), используйте:

vector< vector<short> > getMatrixFromFile(const string &fName) { ... }
void showMatrix(const vector< vector<short> > &mat) { ... }

Единственная сложность заключается в том, что вы можете подумать: "Эй, ссылка означает отсутствие копий! Я буду использовать ее постоянно! Я буду возвращать ссылки из функций!". И вот тут-то ваша программа и рухнет.

Представьте себе следующее:

// Don't do this!
Foo& BrokenReturnRef() {
  Foo f;
  return f;
}

int main() {
  Foo &f = BrokenReturnRef();
  cout << f.bar();
}

К сожалению, это сломано! Когда выполняется BrokenReturnRef, f находится в области видимости и все в порядке. Затем вы возвращаетесь в main и продолжаете ссылаться на f. Стековый кадр, создавший f, исчез, и это местоположение больше не действительно, и вы ссылаетесь на ненужную память. В этом случае вам придется вернуться по значению (или выделить новый указатель на куче).

Единственное исключение из правила "не возвращать ссылки" - это когда вы знаете, что память переживет стек. Именно так STL реализует operator[] для своих контейнеров.

Надеюсь, это поможет! :)

Для передачи по ссылке вы обычно меняете это:

vector<unsigned int> DFS(vector< vector<short> > mat){

на:

vector<unsigned int> DFS(vector<vector<short>> const &mat) { 

Технически это передает ссылку const , но это то, что вы обычно хотите использовать, когда / если вы не планируем изменять исходный объект.

С другой стороны, я бы, вероятно, изменил это:

for_each((*row).begin(), (*row).end(), utilShow<short>);

на что-то вроде:

std::copy(row->begin(), row->end(), std::ostream_iterator<short>(std::cout, " "));

Аналогично:

for_each(dfsResult.begin(), dfsResult.end(), utilShow<unsigned int>);

превратилось бы в:

std::copy(dfsResult.begin(), dfsResult.end(),
          std::ostream_iterator<unsigned int>(std::cout, " "));

(... что, похоже, устранит utilShow целиком).

Что касается 2D-матриц, если вам не нужна рваная матрица (где разные строки могут иметь разную длину), вы обычно используете простой интерфейс для обработки индексации в одном векторе:

template <class T>
class matrix { 
    std::vector<T> data_;
    size_t columns_;
public:
    matrix(size_t rows, size_t columns) : columns_(columns), data_(rows * columns)  {}

    T &operator()(size_t row, size_t column) { return data[row * columns_ + column]; }
};

Обратите внимание, что здесь используется operator () для индексации, поэтому вместо m [x] [y] вы должны использовать m (x, y) , примерно как в BASIC или Фортран. Вы можете перегрузить оператор [] таким образом, чтобы вы могли использовать эту нотацию, если хотите, но это изрядный объем дополнительной работы с (IMO) небольшой реальной пользой.

void utilShow(T& elem);
vector< vector<short> > getMatrixFromFile(const string& fName);
void showMatrix(vector< vector<short> >& mat);
vector<unsigned int> DFS(vector< vector<short> >& mat);

Некоторые из них я смог понять. И по возможности, если вы не меняете или не собираетесь менять состояние объекта внутри тела вашего метода, сделайте передаваемые переменные const.

Я бы не просил вас включать все конструкции C++ в первую попытку, но постепенно, чтобы вы не довели себя до депрессии. Vector является наиболее используемым контейнером STL. И использование контейнеров зависит от ваших потребностей, а не от прихоти использовать один контейнер вместо другого.

Одно краткое описание контейнеров. http://msdn.microsoft.com/en-us/library/1fe2x6kt%28VS.80%29.aspx

@Jerry Спасибо за правку. Вектор не является чрезмерно используемым, но используется больше из-за своей простоты для простых объектов, а не больших монолитных объектов класса. Он похож на массив в стиле C, но не является им, с большим количеством дополнительных алгоритмов. Еще два, которые используются довольно часто, - это карты и списки. Возможно, это так, потому что в местах, где я работаю, использование этих контейнеров требуется чаще, чем в других местах.