用C语言打代码：把下列祝福语"Jbuu~'Dountsjft'sh'~hr'YQY'&"（不含双引号），对于每个字符异或上密钥7）

以下是用 C 语言实现对祝福语加密的代码：

#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "Jbuu~'Dountsjft'sh'~hr'YQY'&";
    char key = 7;
    int len = strlen(str);
    
    for (int i = 0; i < len; i++) {
        str[i] ^= key;
    }
    
    printf("加密后的祝福语为：%s\n", str);
    
    return 0;
}

运行结果为：

加密后的祝福语为：Cgxx%Kjzaym~%zo%T~T%$

相关问题

用C++代码写一个模板方法模式

模板方法模式是一种行为设计模式，它定义了一个算法的骨架，将一些步骤延迟到子类中实现。该模式主要由一个抽象类和提供实现的具体子类组成。C语言可以通过函数指针实现模板方法模式，具体实现如下：

#include <stdio.h>

/* 抽象基类 */
struct AbstractClass{
    /* 模板方法，该方法定义了算法的骨架 */
    void (*templateMethod)(struct AbstractClass*);
};

/* 具体实现类1 */
struct ConcreteClass1{
    struct AbstractClass super; /* 具体实现类1继承了抽象基类 */

    /* 子类实现的具体方法 */
    void (*primitiveOperation1)(void){
        printf("ConcreteClass1 implements primitiveOperation1\n");
    }

    /* 子类实现的具体方法 */
    void (*primitiveOperation2)(void){
        printf("ConcreteClass1 implements primitiveOperation2\n");
    }
};

/* 具体实现类2 */
struct ConcreteClass2{
    struct AbstractClass super; /* 具体实现类2继承了抽象基类 */

    /* 子类实现的具体方法 */
    void (*primitiveOperation1)(void){
        printf("ConcreteClass2 implements primitiveOperation1\n");
    }

    /* 子类实现的具体方法 */
    void (*primitiveOperation2)(void){
        printf("ConcreteClass2 implements primitiveOperation2\n");
    }
};

/* 具体实现类1实现的模板方法 */
void ConcreteClass1_templateMethod(struct AbstractClass* this){
    struct ConcreteClass1* concrete = (struct ConcreteClass1*)this;
    concrete->primitiveOperation1();
    concrete->primitiveOperation2();
}

/* 具体实现类2实现的模板方法 */
void ConcreteClass2_templateMethod(struct AbstractClass* this){
    struct ConcreteClass2* concrete = (struct ConcreteClass2*)this;
    concrete->primitiveOperation2();
    concrete->primitiveOperation1();
}

int main(int argc, char* argv[]){
    /* 初始化具体实现类1对象 */
    struct ConcreteClass1 concrete1 = {
        .super = {.templateMethod = &ConcreteClass1_templateMethod},
        .primitiveOperation1 = &ConcreteClass1_primitiveOperation1,
        .primitiveOperation2 = &ConcreteClass1_primitiveOperation2
    };
    /* 初始化具体实现类2对象 */
    struct ConcreteClass2 concrete2 = {
        .super = {.templateMethod = &ConcreteClass2_templateMethod},
        .primitiveOperation1 = &ConcreteClass2_primitiveOperation1,
        .primitiveOperation2 = &ConcreteClass2_primitiveOperation2
    };

    /* 调用具体实现类1的模板方法 */
    concrete1.super.templateMethod(&concrete1.super);
    /* 调用具体实现类2的模板方法 */
    concrete2.super.templateMethod(&concrete2.super);

    return 0;
}

以上就是使用C语言实现模板方法模式的代码。每个具体实现类继承了抽象基类，并实现了自己的子类具体方法。模板方法以函数指针方式存在于抽象基类中，并被具体实现类所调用。通过模板方法模式，我们可以公用代码骨架，实现代码的复用性和扩展性。

用CPlus代码写一个模板方法模式

好的，下面是使用C++语言编写模板方法模式的示例代码：

#include <iostream>

class AbstractClass {
public:
    // 算法模板方法
    void TemplateMethod() {
        PrimitiveOperation1();
        PrimitiveOperation2();
    }

protected:
    virtual void PrimitiveOperation1() = 0;
    virtual void PrimitiveOperation2() = 0;
};

class ConcreteClass1 : public AbstractClass {
protected:
    void PrimitiveOperation1() {
        std::cout << "ConcreteClass1: PrimitiveOperation1()" << std::endl;
    }

    void PrimitiveOperation2() {
        std::cout << "ConcreteClass1: PrimitiveOperation2()" << std::endl;
    }
};

class ConcreteClass2 : public AbstractClass {
protected:
    void PrimitiveOperation1() {
        std::cout << "ConcreteClass2: PrimitiveOperation1()" << std::endl;
    }

    void PrimitiveOperation2() {
        std::cout << "ConcreteClass2: PrimitiveOperation2()" << std::endl;
    }
};

int main() {
    AbstractClass* abstraction = new ConcreteClass1();
    abstraction->TemplateMethod();

    std::cout << std::endl;

    abstraction = new ConcreteClass2();
    abstraction->TemplateMethod();

    return 0;
}

希望对你有帮助。