C++

<<运算符的重载

ostream&operator<<(ostream& out,Ray& a)函数的作用：

ostream&operator<<(ostream& out,Ray& a)
{
return out<<a.xstate<<" "<<a.ystate<<" "<<a.zstate<<endl;
}

解释：

int main(){
int a(1);
cout<<"a="<<a;
}

cout是outstream类的一个，如上表达式的正确读取方式是：cout<<"a=",然后返回outstream，继续向右读，cout<<a,又返回outstream。最后一次返回outstream没有任何意义

但C++允许把一个返回值放在程序中作为独立一行。就像这样：

int main(){
3;//把返回值为int的3作为独立一行
}

程序中return out<<a.xstate<<" "<<a.ystate<<" "<<a.zstate<<endl;其实就是：

out<<a.xstate;
out<<" ";
out<<y.state;
out<<" ";
out<<a.zstate;
out<<endl;
return out;

opencv图像处理时使用stringstream批量读取图片，处理后并保存

C/C++读取文件名（Ubuntu）

在Ubuntu系统上需要使用C来获取指定文件夹下的文件名

https://blog.csdn.net/lsq2902101015/article/details/51373911

https://blog.csdn.net/weixin_41770169/article/details/94566944

C++中如何将string类型转换为int类型？

#include <string>
#include <sstream>  // 包含头文件

int main()
{
    std::stringstream str2digit;
    std::string sint='1', sfloat='1.1', sdouble='1.2';
    int dint;
    float dfloat;
    double ddouble;
 
    str2digit << sint; str2digit >> dint;  // string to int
    str2digit.clear();
    str2digit << sfloat; str2digit >> dfloat;  // string to float
    str2digit.clear();
    str2digit << sdouble; str2digit >> ddouble;  // string to double

    std::cout << dint << ", " << dfloat << ", " << ddouble << std::endl;

    return 0;
}

C++遍历数组，字符串容器

https://blog.csdn.net/hackmind/article/details/24271949

namespace命名空间

假设这样一种情况，当一个班上有两个名叫 Zara 的学生时，为了明确区分它们，我们在使用名字之外，不得不使用一些额外的信息，比如他们的家庭住址，或者他们父母的名字等等。

同样的情况也出现在 C++ 应用程序中。例如，您可能会写一个名为 xyz() 的函数，在另一个可用的库中也存在一个相同的函数 xyz()。这样，编译器就无法判断您所使用的是哪一个 xyz() 函数。

因此，引入了命名空间这个概念，专门用于解决上面的问题，它可作为附加信息来区分不同库中相同名称的函数、类、变量等。使用了命名空间即定义了上下文。本质上，命名空间就是定义了一个范围。

C++中this与*this的区别

this   *this

return *this返回的是当前对象的克隆或者本身（若返回类型为A， 则是克隆， 若返回类型为A&， 则是本身 ）。return this返回当前对象的地址（指向当前对象的指针） 两个示例如下

#include <iostream>
using namespace std;
 
class A
{
public:
    int x;
    A* get()
    {
        return this;
    }
};
 
int main()
{
    A a;
    a.x = 4;
 
    if(&a == a.get())
    {
        cout << "yes" << endl;
    }
    else
    {
        cout << "no" << endl;
    }
 
    return 0;
}

  结果为:yes

#include <iostream>
using namespace std;
 
class A
{
public:
    int x;
    A get()
    {
        return *this; //返回当前对象的拷贝
    }
};
 
int main()
{
    A a;
    a.x = 4;
 
    if(a.x == a.get().x)
    {
        cout << a.x << endl;
    }
    else
    {
        cout << "no" << endl;
    }
 
    if(&a == &a.get())
    {
        cout << "yes" << endl;
    }
    else
    {
        cout << "no" << endl;
    }
 
    return 0;
}

结果为：

4

no

最后， 如果返回类型是A&， 那么return *this返回的是当前对象本身（也就是其引用）， 而非副本。

C++ 指针

int    var = 20   声明一个数值

int    *a     声明一个指针 

a = &var     // 在指针变量中存储 var 的地址

cout << *ip  输出var

operate运算符转换

c++ const用法

https://blog.csdn.net/leikun153/article/details/80147657

一，const修饰符用于指针

第一种方法是让指针指向一个常量对象，这样可以防止使用该指针来修改所指向的值，第二种方法是将指针本身声明为常量，这样可以防止改变指针的位置。

声明一个指向常量的指针a:

int y = 1;

const int * a = &y;

该声明指出，a指向一个const int，这里为1，因此不能使用a来修改这个值。换句话说，*a的值为const，不能被修改，但是a的声明并不意味着它指向的值实际上就是一个常量，而只是意味着对a而言，这个值是常量。a指向y，而y不是const，可以通过y变量来修改y的值，但不能使用a指针来修改。

        const int m = 9;
        const int * n = &m;  // (1)

        int * t = &m;            //(2) 

        上面的（1）和（2）中看到了什么，（2）将const的地址赋给了常规指针，（1）将const地址赋给了const指针，这两张是否正确呢，答案显然（2）不对，因为C++禁止将const的地址赋给非const指针，如果非要这样做，只能使用强制类型转换来突破这种限制。

int m = 1;
        const int * n = &m;  //(3)

        int * const h = &m;  //(4)

        (3)中声明的const只能防止修改n指向的值，而不能防止修改n的值，也就是说可以将一个新地址赋给n；但仍然不能使用n来修改它指向的值，不允许使用n来修改m的值，但允许将n指向另一个位置。(4)中关键字const的位置与之前的不同，这种声明格式使得h只能指向m,但允许使用h来修改m的值。

三，const int * const 与 const int const *

        int trouble = 2;

        const int * const flag1 = &trouble;  //(5)

        const int const * flag2 = &trouble;  //(6)

        其中（5）flag1只能指向trouble，而flag1不能用来修改trouble的值，即flag1和*flag1都是const。指向的地址和指向的地址的值都不能改变。

        其中（6）同（5）的用法类似，也是指针指向的内存地址不可变，并且指针指向的内存地址的值也不能被修改。

 补充：

int a()const { } 表示a()函数中，类的成员变量不能发生任何改变。a不会对参数进行修改；如果a是结构体或者类的成员，那么也不会对结构体或类的成员变量进行修改

const int a(){ } 这属于一种牵强的写法吧，意思是返回值是一个整型 ， 而且这个返回值是常量

内联函数 inline

内联函数一般放在头文件里面

有时候进出函数的开销比函数本身还大，所以变为内联函数。用宏可能会有bug。

static 静态成员

 类内静态成员变量： 静态成员函数主要为了调用方便，不需要生成对象就能调用。

class X
{
public:
    void MethodA();
    static void MethodB();
}

 此时MethodB可以直接调用，X::MethodB();

MethodA必须先生成类对象才能调用，X x; x.MethodA();