class Solution { public: string addBinary(string a, string b) { reverse(a.begin(),a.end()); reverse(b.begin(),b.end()); string c = ""; int carry =0; int i = 0; int j = 0; while(i<a.size()&&j<b.size()){ int sum = carry; sum+=a.at(i) - '0'; cout<<a.at(i)<<b.at(j)<<endl; sum+=b.at(j) - '0'; carry = sum/2; c+=to_string((sum%2)); i++;j++; } while(i<a.size()){ int sum = carry+ a.at(i++) - '0'; carry = sum/2; c+=to_string(sum%2); } while(j<b.size()){ int sum = carry+ b.at(j++) - '0'; carry = sum/2; c+=to_string(sum%2); } if(carry==1){ c+=to_string(carry); } reverse(c.begin(),c.end()); return c; } }; 这段代码里面 sum+=a.at(i) - '0';这个部分为什么要减去一个0字符

在C++中，字符的ASCII码是以整数形式表示的。当我们执行`a.at(i) - '0'`时，实际上是将字符a.at(i)的ASCII码值减去字符'0'的ASCII码值。这样做的目的是将字符转换为对应的数字。

在ASCII码表中，字符'0'的ASCII码值为48，而字符'1'的ASCII码值为49，以此类推，字符'9'的ASCII码值为57。通过将字符'a.at(i)'的ASCII码值减去字符'0'的ASCII码值，我们可以获得相应的数字。

例如，当a.at(i)为字符'1'时，'1'的ASCII码值是49，而'0'的ASCII码值是48。所以执行`a.at(i) - '0'`结果为1，得到了数字1。

这样做是为了方便进行字符与数字之间的转换，在这段代码中用于将二进制字符串中的字符转换为对应的数字进行计算。

相关问题

class Solution { public: string reverseStr(string s, int k) { for (int i = 0; i < s.size(); i += (2 * k)) { // 1. 每隔 2k 个字符的前 k 个字符进行反转 // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符 if (i + k <= s.size()) { reverse(s.begin() + i, s.begin() + i + k ); } else { // 3. 剩余字符少于 k 个，则将剩余字符全部反转。 reverse(s.begin() + i, s.end()); } } return s; } };

这是一个 C++ 的类 `Solution`，其中包含一个名为 `reverseStr` 的函数，该函数接受两个参数：一个字符串 `s` 和一个整数 `k`。该函数的作用是将字符串 `s` 中每隔 `2k` 个字符的前 `k` 个字符进行反转，如果剩余字符小于 `2k` 但大于或等于 `k` 个，则反转前 `k` 个字符，如果剩余字符少于 `k` 个，则将剩余字符全部反转。最后，该函数返回反转后的字符串 `s`。

在该函数的实现中，使用了一个 `for` 循环来遍历字符串 `s` 中每隔 `2k` 个字符的前 `k` 个字符。在循环内部，使用了一个 `if-else` 条件语句来判断需要反转的字符个数是否小于 `k`。如果小于 `k`，则将剩余字符全部反转，否则只反转前 `k` 个字符。在反转字符的过程中，使用了 C++ 标准库中的 `reverse` 函数。

对class Solution{ public: string removeDuplicateLetters(string s) { vector<int> count(26, 0); vector<bool> inStack(26, false); stack<char> st; for (char c : s) { count[c - 'a']++; } for (char c : s) { count[c - 'a']--; if (inStack[c - 'a']) { continue; } while (!st.empty() && st.top() > c && count[st.top() - 'a'] > 0) { inStack[st.top() - 'a'] = false; st.pop(); } st.push(c); inStack[c - 'a'] = true; } string ans = ""; while (!st.empty()) { ans += st.top(); st.pop(); } reverse(ans.begin(), ans.end()); return ans; } };进行封装，涉及基本数据结构和容器的，需自行编写相应的类，禁止直接使用STL的数据容器类

好的，我来为你封装一下这个函数。

首先，我们需要声明一个类，我们可以将这个类命名为 `DuplicateRemover`。然后，我们需要在这个类中声明一个 `removeDuplicateLetters` 函数，这个函数的参数为一个字符串，返回值也是一个字符串。在这个函数内部，我们需要使用基本数据结构和容器来实现去重，禁止直接使用STL的数据容器类。

我们可以使用一个动态数组（vector）来替代原来的 `count` 数组，使用一个布尔数组来替代原来的 `inStack` 数组，使用一个栈来替代原来的 `st` 栈。在函数外部初始化这些数据结构，并将其作为 `DuplicateRemover` 的成员变量。

具体实现请看下面的代码：

class DuplicateRemover {
public:
    DuplicateRemover() {
        count.resize(26, 0);
        inStack.resize(26, false);
    }

    string removeDuplicateLetters(string s) {
        for (char c : s) {
            count[c - 'a']++;
        }
        for (char c : s) {
            count[c - 'a']--;
            if (inStack[c - 'a']) {
                continue;
            }
            while (!st.empty() && st.top() > c && count[st.top() - 'a'] > 0) {
                inStack[st.top() - 'a'] = false;
                st.pop();
            }
            st.push(c);
            inStack[c - 'a'] = true;
        }
        string ans = "";
        while (!st.empty()) {
            ans += st.top();
            st.pop();
        }
        reverse(ans.begin(), ans.end());
        return ans;
    }

private:
    vector<int> count;
    vector<bool> inStack;
    stack<char> st;
};

现在，我们就可以使用 `DuplicateRemover` 来去重字符串了，示例代码如下：

int main() {
    DuplicateRemover remover;
    string s = "bcabc";
    string ans = remover.removeDuplicateLetters(s);
    cout << ans << endl; // 输出 "abc"
    return 0;
}

以上就是封装后的代码。