输入两个字符串,设计函数连接这两个字符串。单个字符串的长度不超过100。不要使用系统提供的strcat函数。 输入要求 输入2个字符串,每个字符串以换行符结束。 输出要求 输出连接好的字符串。 输入样例 Country side 输出样例 Countryside 模板 #include<stdio.h> @-@ //设计连接字符串的函数 int main() { char s1[202],s2[101]; gets(s1); gets(s2); mystrcat(s1,s2); //调用函数连接字符串 puts(s1); return 0; }
时间: 2024-02-06 11:02:27 浏览: 98
好的,我知道了。以下是实现连接两个字符串的函数mystrcat()的代码:
```
#include <stdio.h>
void mystrcat(char *s1, char *s2) {
while (*s1 != '\0') { // 找到s1的结尾
s1++;
}
while (*s2 != '\0') { // 将s2复制到s1的结尾
*s1 = *s2;
s1++;
s2++;
}
*s1 = '\0'; // 添加s1的结尾标志
}
int main() {
char s1[202], s2[101];
fgets(s1, 202, stdin);
fgets(s2, 101, stdin);
mystrcat(s1, s2);
printf("%s", s1);
return 0;
}
```
函数mystrcat()的具体实现是:首先找到字符串s1的结尾,然后将字符串s2复制到s1的结尾。最后在s1的结尾添加一个字符串结束的标志。在main()函数中,使用fgets()函数输入字符串,并调用mystrcat()函数连接这两个字符串,最后输出连接好的字符串。
相关问题
用C语言设计算法,将两个顺序表示的字符串s和t连接起来。要求:不能用strcat函数
在C语言中,如果没有`strcat`函数,你可以手动编写一个算法来实现字符串连接。这里提供一种简单的链表法,可以创建一个新的字符数组,并逐个复制源字符串s和t的内容:
```c
#include <stdio.h>
#include <stdlib.h>
// 定义结构体存储单个字符及其指向下一个字符的指针
typedef struct CharNode {
char data;
struct CharNode *next;
} CharNode;
// 功能:创建新的字符节点并连接到现有链表
CharNode* addCharToNode(CharNode *node, char c) {
CharNode *newNode = (CharNode*)malloc(sizeof(CharNode));
newNode->data = c;
newNode->next = node;
return newNode;
}
// 功能:连接两个字符串
void concatenateStrings(char *dest, const char *src1, const char *src2) {
CharNode *head = NULL; // 初始化为空链表
while (*src1 != '\0') { // 遍历第一个字符串s
head = addCharToNode(head, *src1++);
}
while (*src2 != '\0') { // 遍历第二个字符串t
CharNode *current = head;
while (current->next != NULL) {
current = current->next;
}
current->next = addCharToNode(current->next, *src2++);
}
// 将头节点添加到结果字符串dest中
*dest++ = head->data;
while (head->next != NULL) {
*dest++ = head->next->data;
head = head->next;
}
*dest = '\0'; // 结束标志
}
int main() {
char result[100];
const char *s = "Hello";
const char *t = "World!";
concatenateStrings(result, s, t);
printf("Concatenated string: %s\n", result);
return 0;
}
定义一个字符串类 String 数据成员(访问权限定义为protected): 指向存放字符串内容的字符指针(char *str) 成员函数(访问权限定义为public): 默认构造函数:初始化成一个空串 String( ); 带参数的构造函数:根据参数内容初始化字符串 String(const char *content); 拷贝构造函数:初始化字符串 String(const String &cstr); 析构函数:释放堆空间 ~String( ); 设置字符串内容 void set(const char *content); 获取字符串内容(定义为const成员函数)void get(char *&dest) const; 获取字符串长度(定义为const成员函数)int length() const; 打印字符串内容(定义为const成员函数)void print() const; 重载赋值运算符= String& operator=(const String &cstr); 重载下标运算符[ ],实现获取字符串中某个指定位置的字符 char& operator[](int index); 重载加法运算符+,实现两个字符串的拼接 String operator+(const String &cstr); 重载加法运算符+,实现字符串和字符指针的拼接 String operator+(const char *cstr); 重载加法运算符+,实现字符串和单个字符的拼接 String operator+(char ch); 重载负号运算符-,实现字符串中字符的逆序排列 String operator-( ); 重载自增运算符++,实现将字符串中的小写字母转换成大写字母 String& operator++(); // 前置自增 String operator++(int); // 后置自增 重载自减运算符--,实现将字符串中的大写字母转换成小写字母 String& operator--(); // 前置自减 String operator--(int); // 后置自减 要求:将类的定义与类成员函数的实现分开。
String.h 文件:
```c++
#ifndef STRING_H
#define STRING_H
class String {
protected:
char *str; // 指向存放字符串内容的字符指针
public:
String(); // 默认构造函数
String(const char *content); // 带参数的构造函数
String(const String &cstr); // 拷贝构造函数
~String(); // 析构函数
void set(const char *content); // 设置字符串内容
void get(char *&dest) const; // 获取字符串内容
int length() const; // 获取字符串长度
void print() const; // 打印字符串内容
String& operator=(const String &cstr); // 重载赋值运算符
char& operator[](int index); // 重载下标运算符
String operator+(const String &cstr); // 重载加法运算符
String operator+(const char *cstr); // 重载加法运算符
String operator+(char ch); // 重载加法运算符
String operator-( ); // 重载负号运算符
String& operator++(); // 重载自增运算符(前置)
String operator++(int); // 重载自增运算符(后置)
String& operator--(); // 重载自减运算符(前置)
String operator--(int); // 重载自减运算符(后置)
};
#endif
```
String.cpp 文件:
```c++
#include <iostream>
#include <cstring>
#include "String.h"
using namespace std;
String::String() {
str = new char[1];
str[0] = '\0';
}
String::String(const char *content) {
if (content == nullptr) {
str = new char[1];
str[0] = '\0';
} else {
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) {
if (content == nullptr) {
delete[] str;
str = new char[1];
str[0] = '\0';
} else {
int len = strlen(content);
if (len != strlen(str)) {
delete[] str;
str = new char[len + 1];
}
strcpy(str, content);
}
}
void String::get(char *&dest) const {
int len = strlen(str);
dest = new char[len + 1];
strcpy(dest, str);
}
int String::length() const {
return strlen(str);
}
void String::print() const {
cout << str << endl;
}
String& String::operator=(const String &cstr) {
if (this != &cstr) {
delete[] str;
int len = strlen(cstr.str);
str = new char[len + 1];
strcpy(str, cstr.str);
}
return *this;
}
char& String::operator[](int index) {
return str[index];
}
String String::operator+(const String &cstr) {
int len1 = strlen(str);
int len2 = strlen(cstr.str);
char *new_str = new char[len1 + len2 + 1];
strcpy(new_str, str);
strcat(new_str, cstr.str);
String result(new_str);
delete[] new_str;
return result;
}
String String::operator+(const char *cstr) {
String temp(cstr);
return (*this + temp);
}
String String::operator+(char ch) {
char cstr[2] = {ch, '\0'};
String temp(cstr);
return (*this + temp);
}
String String::operator-( ) {
int len = strlen(str);
char *new_str = new char[len + 1];
for (int i = 0; i < len; i++) {
new_str[i] = str[len - i - 1];
}
new_str[len] = '\0';
String result(new_str);
delete[] new_str;
return result;
}
String& String::operator++() {
int len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
str[i] += 'A' - 'a';
}
}
return *this;
}
String String::operator++(int) {
String temp(*this);
++(*this);
return temp;
}
String& String::operator--() {
int len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] >= 'A' && str[i] <= 'Z') {
str[i] += 'a' - 'A';
}
}
return *this;
}
String String::operator--(int) {
String temp(*this);
--(*this);
return temp;
}
```
阅读全文