标签: operator-keyword

我正在尝试获取一个包含大量段落的表达式，并在该行中找到包含两个特定单词的行，所以我正在寻找 AND 运算符？有什么办法可以做到这一点吗？

例如：

c <- ("She sold seashells by the seashore, and she had a great time while doing so.")

我想要一个表达式来找到一行中同时包含“已售出”和“很棒”的行。

我尝试过类似的事情：

grep("sold", "great", c, value = TRUE) 

有任何想法吗？

非常感谢！

据我了解 x+=1 与 x=x+1 一样，但为什么它在 String 中不起作用？

String str = "";
str = str + null + true; // fine
str += null + true; // Error message: The operator + is undefined for the argument type(s) null, boolean 

我是 Python 的初学者，试图结合我迄今为止学到的一切来制作一个简单的程序。在这个问题中，程序本身不是问题，而是它的一个特定部分，我已经解决了这个问题，但想深入了解为什么会发生这种情况。

def printresults (answer):
    if answer == "y" or "Y":
        print ("Yes")
    else:
        print ("No")

在上面的例子中，我设法让这个函数以“N”作为“答案”运行。我面临的问题是它会运行第一个 if 分支，在这种情况下打印“是”，尽管它不是“y”或“Y”。

从那以后，我通过在函数中创建一个新变量并使用 lower() 方法只产生一种可能性来解决这个问题，然后简单地要求它确定它是否为“y”。

def printresults (answer):
    lwranswer = answer.lower()
    if lwranswer == "y":
        print ("Yes")
    else:
        print ("No")

因此，我怀疑错误在于我以某种方式滥用了“或”运算符 - 我只是不知道如何或为什么。任何见解将不胜感激。

谢谢

请注意，该程序不会简单地返回“是”或“否”，而是将其打印出来以进行故障排除并查看它采用的分支。

所以问题来了。我有一个 B 类，其中我重载了 << 运算符，还有一个 A 类，其中 << 运算符也重载了。但是，类 B 中的 << 重载似乎在类 A 中的 << 重载中不起作用。它只是返回 b 的地址，就好像类 B 中的 << 重载不存在一样。

任何帮助将不胜感激

#pragma once
#include <ostream>

using namespace std;

class B {
public:

    B(int x) {
        this->x = x;
    }
    
    friend ostream& operator<<(ostream& os, B& b)
    {
        os << "this is B " << b.x;
        return os; 
    }

private:
    int x;
};

#pragma once
#include <ostream>
#include "B.h"

using namespace std;

class A {
public:

    A(B* b) { …

我已经用两个成员变量 a 和 b 创建了两个类 car 对象……我想创建一个新对象，其 a 和 b 是我之前创建的对象的 a 和 b 的乘积。

#include<iostream>
using namespace std;
class car
{
    private:
        int a,b;
    public:
        car(int x,int y)
        {
            a=x;
            b=y;
        }
        void showdata()
        {
            cout<<a<<" "<<b<<endl;
        }
        car add(car c)   // to multiply 'a' and 'b' of both objects and assigning to a new 
                            object 
        {
            car temp;    // new object of class car
            temp.a = a*c.a;   
            temp.b = b*c.b;
            return temp;
        }
        
};
int main()
{
    car …

我重载运算符 << 如下：

std::ostream& operator<<(std::ostream& o, const MyClass& myobj);

现在，我想要有两个版本的operator<<，一个会显示我的对象的简短描述，另一个会显示较长的版本。

例如，MyClass 可以包含有关客户端的信息。在短版本中，我将仅显示姓名，在长版本中，我将显示更多详细信息，例如生日、地址等。

有没有办法在 C++ 中做到这一点？

我知道我可以有一个接收流的 MyClass 方法，但它会被这样调用：

myObj.DisplayShort(cout)

或者

myObj.DisplayLong(cout)

但我想保留类似于通常形式的语法：

cout << myObj << endl;

我的教授表示，可以从单个“基本”运算符派生出迭代器的“所有”运算符，而不会因内联而造成速度损失。

他说：

// To implement ==, != , >, <, >=, <= only only a few cases based on attrbiutes are required
// a == b       ==      !(a>b)&&!(a<b)
// a != b       ==      !(a==b)
// a < b        ==      Implemented as "actual" operator
// a > b        ==      b < a //Argument swap!
// a >= b       ==      a > b || a == b
// a <= b       ==      a < b || a == b

与以下情况相比，不会造成速度损失：

// To …

我是一个时髦的新手.也许这是小菜一碟,但我希望将数组/列表的+运算符重载为这样的代码

def a= [1,1,1]
def b= [2,2,2]

assert [3,3,3] == a + b 

我正在vector<bool>实施.我保存一个unsigned int并使用按位运算来得到一个true和false的向量.我的问题是这个; 我可以通过operator []访问各个位,但是如何获得对这样的位的引用以便我可以写入

Vector<bool> v(5, true);
v[3] = false;

在某处我听说你不应该对各个位做引用/指针.代码摘要,适用于检索位值:

...
unsigned int arr;       // Store bits as unsigned int
unsigned int size_vec;  // The size of "bool vector"
...

bool& Vector<bool>::operator[](unsigned int i) {
 if (i>=vec_size || i<0) {
    throw out_of_range("Vector<bool>::operator[]");
 }
 int index = 1 << (i-1);
 bool n = false;
 if (index & arr) {
     n=true;
 }
 return n;
};

那么,如何才能返回某种参考,从而可以改变各个位？

if ((typed_edge!='Either') || (typed_edge!='Walkable')){
    alert("YES");
    alert("type_edge"+ typed_edge + bus_stops_visited[$k]+ " " +bus_stops_visited[$k+1]);
    }

如果typed_edge具有值Either,则显示警报("YES").

是不是应该不显示？

我想要的是当typed_edge具有值"Either"或"Walkable"时,不显示警报.但似乎并非如此!