这是按值传递还是按引用传递
Is this pass by value or pass by reference?
我正在使用带有C++的cplex。最近，我在看下面的例子。然后我对填充函数感到困惑。这是按值传递的吧？但是为什么在主函数中创建的模型在执行填充函数后会更新呢？它不应该仍然是空模型吗？
// -------------------------------------------------------------- -*- C++ -*-
// File: ilolpex1.cpp
// Version 12.5
// --------------------------------------------------------------------------
// Licensed Materials - Property of IBM
// 5725-A06 5725-A29 5724-Y48 5724-Y49 5724-Y54 5724-Y55 5655-Y21
// Copyright IBM Corporation 2000, 2012. All Rights Reserved.
//
// US Government Users Restricted Rights - Use, duplication or
// disclosure restricted by GSA ADP Schedule Contract with
// IBM Corp.
// --------------------------------------------------------------------------
//
// ilolpex1.cpp - Entering and optimizing a problem. Demonstrates different
// methods for creating a problem. The user has to choose the method
// on the command line:
//
// ilolpex1 -r generates the problem by adding rows
// ilolpex1 -c generates the problem by adding columns
// ilolpex1 -n generates the problem by adding a list of coefficients
#include <ilcplex/ilocplex.h>
ILOSTLBEGIN
static void
usage (const char *progname),
populatebyrow (IloModel model, IloNumVarArray var, IloRangeArray con),
populatebycolumn (IloModel model, IloNumVarArray var, IloRangeArray con),
populatebynonzero (IloModel model, IloNumVarArray var, IloRangeArray con);
int
main (int argc, char **argv)
{
IloEnv env;
try {
IloModel model(env);
if (( argc != 2 ) ||
( argv[1][0] != '-' ) ||
( strchr ("rcn", argv[1][1]) == NULL ) ) {
usage (argv[0]);
throw(-1);
}
IloNumVarArray var(env);
IloRangeArray con(env);
switch (argv[1][1]) {
case 'r':
populatebyrow (model, var, con);
break;
case 'c':
populatebycolumn (model, var, con);
break;
case 'n':
populatebynonzero (model, var, con);
break;
}
IloCplex cplex(model);
cplex.exportModel("lpex1.lp");
// Optimize the problem and obtain solution.
if ( !cplex.solve() ) {
env.error() << "Failed to optimize LP" << endl;
throw(-1);
}
IloNumArray vals(env);
env.out() << "Solution status = " << cplex.getStatus() << endl;
env.out() << "Solution value = " << cplex.getObjValue() << endl;
cplex.getValues(vals, var);
env.out() << "Values = " << vals << endl;
cplex.getSlacks(vals, con);
env.out() << "Slacks = " << vals << endl;
cplex.getDuals(vals, con);
env.out() << "Duals = " << vals << endl;
cplex.getReducedCosts(vals, var);
env.out() << "Reduced Costs = " << vals << endl;
}
catch (IloException& e) {
cerr << "Concert exception caught: " << e << endl;
}
catch (...) {
cerr << "Unknown exception caught" << endl;
}
env.end();
return 0;
} // END main
static void usage (const char *progname)
{
cerr << "Usage: " << progname << " -X" << endl;
cerr << " where X is one of the following options:" << endl;
cerr << " r generate problem by row" << endl;
cerr << " c generate problem by column" << endl;
cerr << " n generate problem by nonzero" << endl;
cerr << " Exiting..." << endl;
} // END usage
// To populate by row, we first create the variables, and then use them to
// create the range constraints and objective.
static void
populatebyrow (IloModel model, IloNumVarArray x, IloRangeArray c)
{
IloEnv env = model.getEnv();
x.add(IloNumVar(env, 0.0, 40.0));
x.add(IloNumVar(env));
x.add(IloNumVar(env));
model.add(IloMaximize(env, x[0] + 2 * x[1] + 3 * x[2]));
c.add( - x[0] + x[1] + x[2] <= 20);
c.add( x[0] - 3 * x[1] + x[2] <= 30);
x[0].setName("x1");
x[1].setName("x2");
x[2].setName("x3");
c[0].setName("c1");
c[1].setName("c2");
model.add(c);
} // END populatebyrow
// To populate by column, we first create the range constraints and the
// objective, and then create the variables and add them to the ranges and
// objective using column expressions.
static void
populatebycolumn (IloModel model, IloNumVarArray x, IloRangeArray c)
{
IloEnv env = model.getEnv();
IloObjective obj = IloMaximize(env);
c.add(IloRange(env, -IloInfinity, 20.0, "c1"));
c.add(IloRange(env, -IloInfinity, 30.0, "c2"));
x.add(IloNumVar(obj(1.0) + c[0](-1.0) + c[1]( 1.0), 0.0, 40.0));
x.add(IloNumVar(obj(2.0) + c[0]( 1.0) + c[1](-3.0)));
x.add(IloNumVar(obj(3.0) + c[0]( 1.0) + c[1]( 1.0)));
x[0].setName("x1");
x[1].setName("x2");
x[2].setName("x3");
model.add(obj);
model.add(c);
} // END populatebycolumn
// To populate by nonzero, we first create the rows, then create the
// columns, and then change the nonzeros of the matrix 1 at a time.
static void
populatebynonzero (IloModel model, IloNumVarArray x, IloRangeArray c)
{
IloEnv env = model.getEnv();
IloObjective obj = IloMaximize(env);
c.add(IloRange(env, -IloInfinity, 20.0));
c.add(IloRange(env, -IloInfinity, 30.0));
x.add(IloNumVar(env, 0.0, 40.0));
x.add(IloNumVar(env));
x.add(IloNumVar(env));
obj.setLinearCoef(x[0], 1.0);
obj.setLinearCoef(x[1], 2.0);
obj.setLinearCoef(x[2], 3.0);
c[0].setLinearCoef(x[0], -1.0);
c[0].setLinearCoef(x[1], 1.0);
c[0].setLinearCoef(x[2], 1.0);
c[1].setLinearCoef(x[0], 1.0);
c[1].setLinearCoef(x[1], -3.0);
c[1].setLinearCoef(x[2], 1.0);
c[0].setName("c1");
c[1].setName("c2");
x[0].setName("x1");
x[1].setName("x2");
x[2].setName("x3");
model.add(obj);
model.add(c);
} // END populatebynonzero
参见 ilocplex.h，可能 IloModel 被定义为指针。或手册中所述的"句柄"。
我无法使用谷歌轻松找到ilocplex.h。但这就是我认为它的工作原理：
struct ModelObj {
int data1, data2, data3;
}
struct Model {
ModelObj* obj;
}
现在，您可以将 Model 作为值传递，但仍obj指向引用。
是的，这些类实际上是"句柄"类 - 实际上只是一些缠绕在一个好的旧指针上的语法糖。原因是这样更容易使代码看起来更干净，并且它允许库更好地控制正在发生的事情，而不仅仅是允许无处不在的指针，并且更容易做一些事情，例如确保对象在自定义堆上分配，通过使用专门的内存管理来获得更好的性能，该内存管理更多地了解它必须管理的对象类型。自 90 年代末以来，我一直在许多项目中使用 CPLEX，并用它教授了许多课程。如果做得好，它可以使代码更干净。就在实现自己的自定义扩展时，有时需要同时编写实现类和句柄类，这在开始时可能会令人困惑......
请检查：
-
您的头文件是否具有自定义的复制构造函数？
-
类
IloModel是基于指针的类型吗？就像说明书提到的那样？
自定义复制构造函数的详细说明
您的代码是否具有自定义的复制构造函数，尤其是当类在堆中创建一些数据字段时。 请检查您的代码以了解类 IloModel 的定义。
-
如果没有自定义的副本构造，则应按值传递模型类。
-
如果定义了自定义的复制构造函数，并且仅使用引用，则可以通过引用传递。
下面是一段代码，可以向您展示这种类型的构造函数是如何工作的：
#include <string>
#include <iostream>
using namespace std;
class person {
public:
std::string _name;
int* _age_ptr;
person (const std::string& name, int age) {
_name = name;
_age_ptr = new int(age);
}
person(const person& that) { // The customized copy constructor
_name = that._name;
_age_ptr = that._age_ptr;
cout << "run copy constructor" << endl;
}
void print() {
cout << "name:" << _name <<", age:" << *_age_ptr << endl;
}
};
person update_age( person that) {
cout << "Set age tp 70" << endl;
*that._age_ptr = 70;
return that;
}
int main() {
person a("Jim", 60);
cout <<"Before update, a" << endl;
a.print(); // Output: name:Jim, age 60
cout << endl;
person b = update_age(a);
cout <<"After update, a" << endl;
a.print(); // HERE Output: name:Jim, age 70
cout << endl;
cout <<"After update, b" << endl;
b.print();
return 0;
}
有关复制构造函数的更多信息，这里有一个有用的链接：什么是复制和交换习惯用法？
相关文章：
- 何时应通过引用传递矢量参数而不是按值传递矢量参数?
- 棘手的按值传递和按引用递归问题传递
- 不同于按值传递和常量引用传递的程序集
- 按值传递变量与按引用传递变量具有相同的结果
- 为什么按值传递QStringView比引用常量更快?
- 获取 std::函数以推断按引用传递/按值传递
- C++/11 auto 关键字是在更有效时推导参数进行按引用传递，还是始终按值传递?
- 使用 enable_if 在按值传递与按引用传递之间更改函数声明
- C++按引用传递还是按值传递?
- 可移动但不可复制的对象:按值传递还是按引用传递?
- C++11 按 POD 类型的值传递比常量引用差
- 如何在 C++14 中编写用于调用 Fortran 函数的通用包装器(按引用调用 --按值调用>)
- 为什么编译器可以通过引用传递和值传递来重载函数
- 为什么要按 C++ 中的值传递对象
- C++:如何决定是按引用还是按值传递参数
- 迷失在通过引用、通过值传递的参数中
- 通过引用与通过值传递指向函数的指针，以及在指针链上使用delete
- c++按引用传递、值传递和Const问题
- 复制赋值运算符应该通过常量引用还是通过值传递
- 具有抽象基类的工厂模式 - 按引用或按值返回?范围界定和切片问题
