用c++设计一个函数print打印字符串，如果只传string型参数s，则字符串长度跟10比较，大于10，打印前10个字符，小于10，全部输出s；如果传string型参数s和int型n，则字符串长度跟n比较，大于n，打印前n个字符，小于n，全部输出s。

以下是实现该函数的代码：

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

void print(char *s, int n) {
    int len = strlen(s);
    if (n <= 0) {
        printf("Error: n should be greater than 0.\n");
        return;
    }
    if (len <= n) {
        printf("%s\n", s);
    } else {
        char tmp = s[n];
        s[n] = '\0';
        printf("%s\n", s);
        s[n] = tmp;
    }
}

int main() {
    char s[] = "This is a test string.";
    print(s, 5);
    print(s, 20);
    print(s, -1);
    return 0;
}

输出结果为：

This 
This is a test string.
Error: n should be greater than 0.

第一个调用打印了字符串的前5个字符，第二个调用打印了整个字符串，第三个调用因为n小于等于0而出错。

相关问题

用c++语言做题:设计一个函数print打印字符串，如果只传string型参数s，则字符串长度跟10比较，大于10打印前10个字符，小于10则全部输出s。如果传string型参数s和int型n，则字符串长度跟n比较，大于n，打印前n个字符，小于n，全部输出s

### 回答1：
下面是实现该功能的 C 语言函数：

void print(char *s, int n) {
    int len = strlen(s);
    if (len > n) {
        s[n] = '\0'; // 截断字符串
    }
    printf("%s\n", s);
}

若只传一个字符数组参数，调用方式为：

print("hello, world!", 10);

若再传入一个整型参数，则调用方式为：

print("hello, world!", 5);

### 回答2：
下面是用C语言编写的函数print，实现上述要求：

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

void print(char *s, int n) {
    int len = strlen(s);
    
    if (len > n) {
        char *temp = malloc((n+1) * sizeof(char));
        strncpy(temp, s, n);
        temp[n] = '\0';
        printf("%s\n", temp);
        free(temp);
    } else {
        printf("%s\n", s);
    }
}

int main() {
    char str1[] = "Hello World!";
    char str2[] = "Hello";
    char str3[] = "Hi";
    
    print(str1, 10);  // 打印前10个字符
    print(str2, 10);  // 打印整个字符串
    print(str3, 5);   // 打印整个字符串
    
    return 0;
}

然后将上述代码保存为.c文件，并通过编译器对其进行编译运行。输出结果为：

Hello Worl
Hello
Hi

以上代码中，函数`print`接受两个参数：一个是字符串`s`，另一个是整数`n`。首先通过`strlen`函数获取字符串`s`的长度`len`，然后进行判断：

- 若`len`大于`n`，则需要截取前`n`个字符并输出。首先分配一个大小为`(n+1)`的字符数组`temp`，然后使用`strncpy`函数将前`n`个字符拷贝到`temp`中。注意，这里需要额外给`temp`数组的最后一个元素加上`\0`作为字符串的结束符。最后，使用`printf`函数输出`temp`并释放动态分配的内存。
- 若`len`小于等于`n`，则直接输出整个字符串`s`。

在`main`函数中，我们提供了三个示例调用`print`函数的例子进行测试。

### 回答3：
下面是用C语言编写的函数print，实现了题目要求的功能：

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

void print(char* s, int n) {
    int len = strlen(s);
    if (len > n) {
        for (int i = 0; i < n; i++) {
            printf("%c", s[i]);
        }
    } else {
        printf("%s", s);
    }
}

int main() {
    char s[100];
    int n;

    printf("请输入字符串: ");
    scanf("%s", s);
    printf("请输入n的值: ");
    scanf("%d", &n);

    print(s, n);

    return 0;
}

该函数首先使用strlen函数获取字符串s的长度，然后通过与n的比较，确定打印的字符数。

若s的长度大于n，则使用for循环打印s的前n个字符。

若s的长度小于等于n，则使用printf函数直接打印整个字符串s。

在main函数中，先读入字符串s和整数n的值，然后调用print函数进行打印。

定义一个字符串类 String 数据成员（访问权限定义为protected）： 指向存放字符串内容的字符指针（char *str） 成员函数（访问权限定义为public）： 默认构造函数：初始化成一个空串 String( ); 带参数的构造函数：根据参数内容初始化字符串 String(const char *content); 拷贝构造函数：初始化字符串 String(const String &cstr); 析构函数：释放堆空间 ~String( ); 设置字符串内容 void set(const char *content); 获取字符串长度（定义为const成员函数）int length() const; 打印字符串内容（定义为const成员函数）void print() const; 重载赋值运算符= （只能作为类成员函数重载） String& operator=(const String &cstr); String& operator=(const char *cstr); 重载下标运算符[ ]，实现获取字符串中某个指定位置的字符 （只能作为类成员函数重载） char& operator[](int index); 重载类型转换运算符 char *，实现将字符串类强制转换成字符指针（只能作为类成员函数重载） operator char*( ); 要求：将类的定义与类成员函数的实现分开。

类定义如下：

class String {
protected:
    char* str;  // 存储字符串内容的字符指针
public:
    String();  // 默认构造函数
    String(const char* content);  // 带参数的构造函数
    String(const String& cstr);  // 拷贝构造函数
    ~String();  // 析构函数
    void set(const char* content);  // 设置字符串内容
    int length() const;  // 获取字符串长度
    void print() const;  // 打印字符串内容
    String& operator=(const String& cstr);  // 重载赋值运算符=
    String& operator=(const char* cstr);  // 重载赋值运算符=
    char& operator[](int index);  // 重载下标运算符[]
    operator char*();  // 重载类型转换运算符
};

类成员函数的实现如下：

// 默认构造函数
String::String() {
    str = new char[1];
    str[0] = '\0';
}

// 带参数的构造函数
String::String(const char* content) {
    int len = strlen(content);
    str = new char[len + 1];
    strcpy(str, content);
}

// 拷贝构造函数
String::String(const String& cstr) {
    int len = strlen(cstr.str);
    str = new char[len + 1];
    strcpy(str, cstr.str);
}

// 析构函数
String::~String() {
    delete[] str;
}

// 设置字符串内容
void String::set(const char* content) {
    delete[] str;
    int len = strlen(content);
    str = new char[len + 1];
    strcpy(str, content);
}

// 获取字符串长度
int String::length() const {
    return strlen(str);
}

// 打印字符串内容
void String::print() const {
    printf("%s", str);
}

// 重载赋值运算符=
String& String::operator=(const String& cstr) {
    if (this == &cstr) return *this;  // 自我赋值
    delete[] str;
    int len = strlen(cstr.str);
    str = new char[len + 1];
    strcpy(str, cstr.str);
    return *this;
}

String& String::operator=(const char* cstr) {
    delete[] str;
    int len = strlen(cstr);
    str = new char[len + 1];
    strcpy(str, cstr);
    return *this;
}

// 重载下标运算符[]
char& String::operator[](int index) {
    return str[index];
}

// 重载类型转换运算符
String::operator char*() {
    return str;
}