biscuitの博客

1
int x = 10;
2
&x;  // &x 获取变量x的地址

1
int a = 10,c=60;
2
int& b = a;
3
// b 是 a 的引用，即 b 和 a 共享同一块内存
4
// 现在对 b 的任何修改都会影响 a
5
b = c; // 这是“把 c 的值赋给 a”，而不是“让 b 改绑到 c”

1
#include <iostream>
2

3
void modifyValue(int x) {
4
    x = 20;  // 仅修改函数内部的副本
5
}
6

7
int main() {
8
    int a = 10;
9
    modifyValue(a);  // 传入 a 的副本，副本在函数结束后被销毁，真正的 a 的值不会改变
10
    std::cout << a;   // 输出 10，原始变量 a 没有变化
11
    return 0;
12
}

1
virtual void init(const std::vector<boost::any> &param) = 0;

1
virtual Eigen::MatrixXd& getResult() = 0;

1
Eigen::MatrixXd& KF::getResult() { return m_statePost; }

1
class MyClass {
2
public:
3
    static int staticVar; // 静态成员变量声明
4
    inline static int inlineStaticVar = 42; // C++17及以上版本支持类内初始化
5
};
6

7
int MyClass::staticVar = 0; // 静态成员变量定义和初始化

1
virtual 返回类型 function(params);

1
virtual 返回类型 function(params) = 0;

1
返回类型 function(params) override{函数实现}

1
class Base {//基类
2
public:
3
        virtual void pureVirtualFunction() = 0;  // 纯虚函数
4
};
5
//派生类
6
class Derived : public Base {
7
public:
8
    void pureVirtualFunction() override {  // 必须提供实现
9
        std::cout << "Derived class implementation" << std::endl;
10
    }
11
};

1
virtual void setParam(const std::vector<boost::any> &param) = 0;   // 设置在迭代过程中会改变的参数
2
virtual void stateUpdate();//更新卡尔曼滤波中的状态空间

1
virtual void setParam(const std::vector<boost::any> &param) override;

1
MyKalmanFilter& MyKalmanFilter::setStateByMeasure() {
2
static Eigen::Vector3d lastMeasurement;
3
static Eigen::Vector3d lastVelocity;
4
//省略114514行
5
}

1
class MyClass {
2
private:
3
    int x;
4
    const int y; // 常量成员变量
5
    int& z;       // 引用成员变量
6
public:
7
    MyClass(int a, int b, int& c) : x(a), y(b), z(c) // 初始化列表
8
    {
9
        // 其他初始化代码
10
    }
11
};

1
//构造函数，接收两个参数measureDim->m_measureDimension;stateDim->m_stateDimension
2
    KF(const int measureDim, const int stateDim)
3
        : m_measureDimension(measureDim), m_stateDimension(stateDim)
4
        {//其他初始化
5
        }
6
    //其他成员变量
7

8
    const int m_measureDimension;  // 测量向量的维度
9
    const int m_stateDimension;  // 状态向量的维度

1
MyClass obj1;          // 调用默认构造函数
2
MyClass obj2(10);      // 调用带参数的构造函数，()里面就是传给构造函数的参数
3
MyClass* obj3 = new MyClass(20); // 动态分配对象，调用带参数的构造函数
4
Detctor::detect():m_globalRoi{0, 0, image.Width,image.Height} {}// 传入参数列表

1
MyClass(); // 创建一个匿名对象，调用默认构造函数
2
MyClass(30); // 创建一个匿名对象，调用带参数的构造函数

1
drawCircle(cv::Scalar(0, 0, 255)); // 直接传入构造的对象

1
#include <iostream>
2
using namespace std;
3
class Demo {
4
private:
5
  int num;
6
  char ch;
7
public:
8
  void setMyValues(int num, char ch){
9
    this->num = num;
10
    this->ch = ch;
11
  }
12
  void displayMyValues(){
13
    cout << num << endl;
14
    cout << ch;
15
  }
16
};
17
int main(){
18
  Demo obj;
19
  obj.setMyValues(100, 'A');
20
  obj.displayMyValues();
21
  return 0;
22
}

1
#include <iostream>
2
using namespace std;
3
class Demo {
4
public:
5
  Demo& setMyValues(int num, char ch) {//返回当前对象的引用
6
    this->num = num;
7
    this->ch = ch;
8
    return *this;
9
  }
10
  void displayMyValues() {
11
    this->num = num++;//这里体现链式调用，对对象的数据成员所做的更改将保留以进一步链式调用。
12
    cout << num << endl;
13
    cout << ch;
14
  }
15
private:
16
  int num;
17
  char ch;
18
};
19
int main() {
20
  Demo obj;
21
  obj.setMyValues(100, 'A').displayMyValues(); // 链式调用
22
  return 0;
23
}

1
101 //先setMyValues(100,'A')，然后displayMyValues()，num++，所以是101
2
A