复制代码系统环境：win10
编辑器：IDEA

scss复制代码Eureka是springcloud中的注册中心。
原因：
当是单体应用 类似一条直线
随着项目越来越大 系统拆分 类似那个藕(模块间相互协作 调用) 为了解决服务之间的耦合 注册中心有必要出现了

arduino复制代码Eureka分为两部分：服务端和客户端，服务端就是注册中心，接收其他服务注册，客户端则是Java客户端，用来注册。

Eureka有三个角色：
Eureka Server：注册中心
Eureka Provider：服务提供者
Eureka Consumer：服务消费者

复制代码Eureka由Java开发的，springcloud使用springboot对Eureka进行了封装，使用方便。

yaml复制代码# 给当前服务取一个名字
spring:
  application:
    name: eureka

# 设置端口号
server:
  port: 1234

# 默认情况下 Eureka Server也是一个普通的微服务 即当它是一个注册中心的时候 他有2种 1：注册中心 2：普通服务(把自己注册到自己的上面去)
# 比喻不形象 Server是一个结婚登记处 1：他是一个登记员 登记其他人的结婚信息 2：同时他也是人类的一员 他也可能结婚 那么自己登记自己老 也不是不可以

# register-with-eureka为false 表示不把当前项目注册到服务中心上
# fetch-registry为false 表示不从Eureka Server上获取注册信息
eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

scss复制代码注册中心使用之后 所有服务都要通过服务注册中心进行信息交换 服务注册中心的稳定性很重要 一旦注册中心崩了 整个系统都会受到影响 在实际使用中 Eureka一般是以集群的形式出现的

Eureka集群 多个Eureka实例的启动 多Eureka实例之间 相互注册、同步数据 共同组成一个Eureka集群
(你中有我 我中有你 互通有无)

yaml复制代码# 给当前服务取一个名字
spring:
  application:
    name: eureka

# 设置端口号
server:
  port: 1234


# 默认情况下 Eureka Server也是一个普通的微服务 即当它是一个注册中心的时候 他有2种 1：注册中心 2：普通服务(把自己注册到自己的上面去)
# 比喻不形象 Server是一个结婚登记处 1：他是一个登记员 登记其他人的结婚信息 2：同时他也是人类的一员 他也可能结婚 那么自己登记自己老 也不是不可以

# register-with-eureka为false 表示不把当前项目注册到服务中心上
# fetch-registry为false 表示不从Eureka Server上获取注册信息
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    # A服务要注册到B上面
    service-url:
      defaultZone: http://eurekaB:1235/eureka
  instance:
    hostname: eurekaA

yaml复制代码# 给当前服务取一个名字
spring:
  application:
    name: eureka

# 设置端口号
server:
  port: 1235

# 默认情况下 Eureka Server也是一个普通的微服务 即当它是一个注册中心的时候 他有2种 1：注册中心 2：普通服务(把自己注册到自己的上面去)
# 比喻不形象 Server是一个结婚登记处 1：他是一个登记员 登记其他人的结婚信息 2：同时他也是人类的一员 他也可能结婚 那么自己登记自己老 也不是不可以

# register-with-eureka为false 表示不把当前项目注册到服务中心上
# fetch-registry为false 表示不从Eureka Server上获取注册信息
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    # A服务要注册到B上面
    service-url:
      defaultZone: http://eurekaA:1234/eureka
instance:
  hostname: eurekaB

css复制代码java jar xxxx.jar --spring.profiles.active=a
java jar xxxx.jar --spring.profiles.active=b

复制代码启动2个实例时 可能会报一些错 不影响使用 页面登陆不了 排除你自己哪里写的有问题了

复制代码启动成功后 确实是相互注册了 共建了一个集群

arduino复制代码Eureka分为Eureka Server和Eureka Client

scss复制代码对外提供的功能：
(服务端的接收 发放 同步server端)
1.服务注册(接收) 所有服务都注册到server端
2.提供注册表(发放) 注册表将所有注册到服务上来的整理成一个列表 Eureka调用服务时 获取这个注册表 正常情况下 注册表会缓存下来 若缓存失效 直接获取最新的注册表
3.同步状态 Eureka Client通过注册、心跳等机制 和Eureka Server同步当前客户端的状态

vbscript复制代码Eureka Client很多事情帮你做了(自动拉取 更新以及缓存server信息 哪怕所有server节点凉了 client依旧能获取到想要的地址(但是地址可能不太准确)) 简化每个服务和server之间的交互

arduino复制代码服务提供者将自己注册到服务注册中心(server) 提示->服务提供者(业务划分上的划分) 本质上是Eureka Client 当Eureka Client向Eureka Server注册时 需要提供必要的元信息 比如IP地址 名称 运行状态 端口等。。。

arduino复制代码Eureka Client注册到Eureka Server上之后 注册成功后 Eureka Client每隔30s向Eureka发送一条心跳信息(告诉它我还活着)  若连续90s(连续3次没法送)有没有收到Eureka Client的续约消息 它会认为Client挂了 赶紧把client从服务列表撤销

yaml复制代码eureka:
  instance:
    # 服务续约时间 默认为30s
    lease-renewal-interval-in-seconds: 30
    # 服务失效时间 默认为90s
    lease-expiration-duration-in-seconds: 90

vbscript复制代码当client下线时 发消息通知server我下线了

arduino复制代码Eureka Client从Eureka Server上获取服务的注册信息 将其缓存在本地 本地客户端调用服务器  会从该信息中查找远程服务所对应的IP地址等信息 Eureka Client上缓存服务定期30s更新 若本地缓存注册表的信息与server传过来的信息有变化的话 Client会自动处理

yaml复制代码eureka:
  client
    # 是否运行获取注册表信息
    fetch-registry: true
    # Client上缓存的服务注册信息 定期30s更新
    registry-fetch-interval-seconds: 30

rust复制代码在这个图上 Eureka通过Replicate进行数据同步 不同Eureka Server之间的节点地位均等 节点间集群的形成 通过置顶的serviceUrl相互注册 高可用节点的可用性得到提高 

若集群中某个节点失效 client自动切换到其他server上(每个server节点相互同步) Eureka连接方式 不建议单线连接(1->2->3 此时1也会和3互相同步) 可以指定多个注册地址(这样配置serviceUrl 1->2 1->3) 

Eureka分区：
1.region->地理上的不同区域
2.zone->具体的机房

vbscript复制代码1.注册中心的出现解决了服务间的耦合

2.Eureka三种角色 server(注册中心) client(provider(提供者) consumer(服务消费者) )

3.Eureka搭建 引入依赖 在application上开启server服务 在yml中配置服务名 端口号。。。启动成功后 会显示系统状态 副本 注册上来的服务信息 系统运行环境 以及该的一些ip等基本信息

4.eureka集群(类似互联网 离了你照转) 比如需要2个eureka yml配置 注 register-with-eureka: true fetch-registry: true 配置一个hostname serviceUrl->其他yml的(http://hostname:port/application name)
为了省事 打包运行 即可看到相互注册了

5.eureka细节 server -> 对外提供3个功能：给予服务注册(接收) 提供注册表 便于client的调用 同步 判断client是否活着 活着才能同步 否则就被杀掉(无情) 
    client -> 特色:自动拉取 更新 缓存信息      
      服务注册:服务提供者将自己注册上去(业务划分出2个角色 本质是一个人) 注册时需要提供一些元信息 ip啥的(类似身份证 手机号啥的 证明你是你开玩笑的 好认识你和你交朋友) 
      服务续约:注册上来 噩梦刚开始 client向server30s续约(费)一次 告诉server别杀我 我还活着 server连续3次90s未接收到client消息 掉线了(类似在黑吧 当你时间到了 给你3次机会 你还没有付费 你个穷鬼 别站在茅坑不拉屎 赶紧下来) 就这样被server从服务列表中剔除了
      服务下线:告诉server我下线了(老板 我下线了 我结一下帐)
      获取注册表信息(消费者):从server上获取信息 缓存本地 更新操作 -> 根据信息比对是否进行更新处理
      提供者:向server注册 提供自身的信息 以及与server心跳时间(存活)的约定 以及服务下线的功能
      消费者:从server获取服务注册信息 并缓存 定期对比该服务信息进行更新处理

6.集群
    server每个节点地位平等 通过Replicate数据同步 serverUrl相当于拨号 节点相互之间的连接方式(某个节点崩溃怎么办) 脚踏"两"只船

perl复制代码PUT my-index-000001
{
  "mappings": {
    "date_detection": false
  }
}

perl复制代码PUT my-index-000001
{
  "mappings": {
    "dynamic_date_formats": ["MM/dd/yyyy"]
  }
}

PUT my-index-000001/_doc/1
{
  "create_date": "09/25/2015"
}

perl复制代码PUT my-index-000001
{
  "mappings": {
    "numeric_detection": true
  }
}

PUT my-index-000001/_doc/1
{
  "my_float":   "1.0", 
  "my_integer": "1" 
}

perl复制代码PUT my-index-000001/
{
  "mappings": {
    "dynamic_templates": [
      {
        "strings_as_ip": {
          "match_mapping_type": "string",
          "match": "ip*",
          "runtime": {
            "type": "ip"
          }
        }
      }
    ]
  }
}

perl复制代码PUT my-index-000001
{
  "mappings": {
    "dynamic_templates": [
      {
        "integers": {
          "match_mapping_type": "long",
          "mapping": {
            "type": "integer"
          }
        }
      },
      {
        "strings": {
          "match_mapping_type": "string",
          "mapping": {
            "type": "text",
            "fields": {
              "raw": {
                "type":  "keyword",
                "ignore_above": 256
              }
            }
          }
        }
      }
    ]
  }
}

json复制代码  "match_pattern": "regex",
  "match": "^profit_\d+$"

perl复制代码PUT my-index-000001
{
  "mappings": {
    "dynamic_templates": [
      {
        "full_name": {
          "path_match":   "name.*",
          "path_unmatch": "*.middle",
          "mapping": {
            "type":       "text",
            "copy_to":    "full_name"
          }
        }
      }
    ]
  }
}

perl复制代码PUT my-index-000001
{
  "mappings": {
    "dynamic_templates": [
      {
        "named_analyzers": {
          "match_mapping_type": "string",
          "match": "*",
          "mapping": {
            "type": "text",
            "analyzer": "{name}"
          }
        }
      },
      {
        "no_doc_values": {
          "match_mapping_type":"*",
          "mapping": {
            "type": "{dynamic_type}",
            "doc_values": false
          }
        }
      }
    ]
  }
}

bash复制代码GET test/_mapping

Result：
{
  "test" : {
    "mappings" : {
      "properties" : {
        "description" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "name" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        },
        "title" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    }
  }
}

perl复制代码PUT /my-index-000003
{
  "mappings": {
    "properties": {
      "age":    { "type": "integer" },  
      "email":  { "type": "keyword"  }, 
      "name":   { "type": "text"  }     
    }
  }
}

bash复制代码PUT /my-index-000003/_mapping
{
  "properties": {
    "employee-id": {
      "type": "keyword",
      "index": false
    }
  }
}

bash复制代码# 查看索引
GET /my-index-000003/_mapping

json复制代码{
  "my-index-000003" : {
    "mappings" : {
      "properties" : {
        "age" : {
          "type" : "integer"
        },
        "email" : {
          "type" : "keyword"
        },
        "employee-id" : {
          "type" : "keyword",
          "index" : false
        },
        "name" : {
          "type" : "text"
        }
      }
    }
  }
}

bash复制代码# 查看索引的特定字段
GET /my-index-000003/_mapping/field/age

json复制代码{
  "my-index-000003" : {
    "mappings" : {
      "age" : {
        "full_name" : "age",
        "mapping" : {
          "age" : {
            "type" : "integer"
          }
        }
      }
    }
  }
}

arduino复制代码输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

arduino复制代码输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
输出：true

arduino复制代码输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
输出：false

c复制代码bool dfs(vector<vector<char>>& board, string& word,int u,int x,int y)

c复制代码class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        for(int i = 0; i < board.size(); i++)
            for(int j = 0; j < board[i].size(); j++)
                if(dfs(board,word,0,i,j)) return true;
        return false;        
    }
    int dx[4] = {-1,0,1,0}, dy[4] = {0,1,0,-1}; //方向数组
    bool dfs(vector<vector<char>>& board, string& word,int u,int x,int y)
    {
        if(board[x][y] != word[u]) return false;
        if(u == word.size() - 1)   return true;
        char t = board[x][y];
        board[x][y] = '.';
        for(int i = 0; i < 4; i++)
        {
            int a = x + dx[i], b = y + dy[i];
            //出界或者走到已经搜索过的位置
            if(a < 0 || a >= board.size() || b < 0 || b >= board[0].size() || board[a][b] == '.')  continue;
            if(dfs(board,word,u+1,a,b)) return true;
        }
        board[x][y] = t;
        return false;
    }
};

java复制代码class Solution {
    public boolean exist(char[][] board, String word) {
        for(int i = 0; i < board.length; i++)
            for(int j = 0; j < board[i].length; j++)
                if(dfs(board,word,0,i,j)) return true;
        return false;   
    }
    int[] dx = new int[]{-1,0,1,0}, dy = new int[]{0,1,0,-1};
    boolean dfs(char[][] board, String word,int u,int x,int y)
    {
        if(board[x][y] != word.charAt(u)) return false;
        if(u == word.length() - 1)   return true;
        char t = board[x][y];
        board[x][y] = '.';
        for(int i = 0; i < 4; i++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(a < 0 || a >= board.length|| b < 0 || b >= board[0].length || board[a][b] == '.')  continue;
            if(dfs(board,word,u+1,a,b)) return true;
        }
        board[x][y] = t;
        return false;
    }
}

typescript复制代码public class Singleton_00 {

    public static Map<String,String> cache = new ConcurrentHashMap<String, String>();
    
}

csharp复制代码public class Singleton_01 {

    private static Singleton_01 instance;

    private Singleton_01() {
    }

    public static Singleton_01 getInstance(){
        if (null != instance) return instance;
        instance = new Singleton_01();
        return instance;
    }

}

csharp复制代码public class Singleton_02 {

    private static Singleton_02 instance;

    private Singleton_02() {
    }

    public static synchronized Singleton_02 getInstance(){
        if (null != instance) return instance;
        instance = new Singleton_02();
        return instance;
    }

}

csharp复制代码public class Singleton_03 {

    private static Singleton_03 instance = new Singleton_03();

    private Singleton_03() {
    }

    public static Singleton_03 getInstance() {
        return instance;
    }

}

csharp复制代码public class Singleton_04 {

    private static class SingletonHolder {
        private static Singleton_04 instance = new Singleton_04();
    }

    private Singleton_04() {
    }

    public static Singleton_04 getInstance() {
        return SingletonHolder.instance;
    }

}

csharp复制代码public class Singleton_05 {

    private static volatile Singleton_05 instance;

    private Singleton_05() {
    }

    public static Singleton_05 getInstance(){
       if(null != instance) return instance;
       synchronized (Singleton_05.class){
           if (null == instance){
               instance = new Singleton_05();
           }
       }
       return instance;
    }

}

csharp复制代码public class Singleton_06 {

    private static final AtomicReference<Singleton_06> INSTANCE = new AtomicReference<Singleton_06>();

    private static Singleton_06 instance;

    private Singleton_06() {
    }

    public static final Singleton_06 getInstance() {
        for (; ; ) {
            Singleton_06 instance = INSTANCE.get();
            if (null != instance) return instance;
            INSTANCE.compareAndSet(null, new Singleton_06());
            return INSTANCE.get();
        }
    }

    public static void main(String[] args) {
        System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d
        System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d
    }

}

csharp复制代码public enum Singleton_07 {

    INSTANCE;
    public void test(){
        System.out.println("hi~");
    }

}

typescript复制代码@Test
public void test() {
    Singleton_07.INSTANCE.test();

c复制代码__FILE__    //进行编译的源文件
__LINE__   //文件当前的行号
__DATE__   //文件被编译的日期
__TIME__   //文件被编译的时间
__STDC__   //如果编译器遵循ANSI C，其值为1，否则未定义

c复制代码#define MAX 1000
#define reg register      //为 register这个关键字，创建一个简短的名字
#define do_forever for(;;)   //用更形象的符号来替换一种实现
#define CASE break;case     //在写case语句的时候自动把 break写上。
// 如果定义的 stuff过长，可以分成几行写，除了最后一行外，每行的后面都加一个反斜杠(续行符)。
#define DEBUG_PRINT printf("file:%s\tline:%d\t \
             date:%s\ttime:%s\n" ,\
             __FILE__,__LINE__ ,    \
             __DATE__,__TIME__ )

c复制代码#define MAX 1000;
#define MAX 1000

c复制代码x+1;//不带副作用
x++;//带有副作用

c复制代码#define MAX(a, b) ((a)>(b)?(a):(b))

c复制代码#if 常量表达式
//...
#endif

C复制代码//常量表达式由预处理器求值。
#define __DEBUG__ 1
#if __DEBUG__
//..
#endif

c复制代码#if 常量表达式
//...
#elif 常量表达式
//...
#else
//...
#endif

c复制代码#if defined(symbol)
#ifdef symbol
#if !defined(symbol)
#ifndef symbol

c复制代码#if defined(OS_UNIX)
#ifdef OPTION1
unix_version_option1();
#endif
#ifdef OPTION2
unix_version_option2();
#endif
#elif defined(OS_MSDOS)
#ifdef OPTION2
msdos_version_option2();
#endif
#endif

C复制代码#include "filename"

c复制代码#include <filename.h>

python复制代码list(map(fact, range(6)))		# [1, 1, 2, 6, 24, 120] 阶乘
[fact(n) for n in range(6)]		# [1, 1, 2, 6, 24, 120]

list(map(factorial, filter(lambda n: n % 2, range(6)))) 	# [1, 6, 120]
[factorial(n) for n in range(6) if n % 2] 					# [1, 6, 120]

xml复制代码<!--配置-->
<configuration>
    <!--属性-->
    <properties>
    <!--设置-->
    <settings>
    <!--类型别名-->
    <typeAliases>
    <!--类型处理器-->
    <typeHandlers>
    <!--对象工厂-->
    <objectFactory>
    <!--插件-->
    <plugins>
    <!--环境配置-->
    <environments>
    <!--数据库厂商标识-->
    <databaseIdProvider>
    <!--映射器-->
    <mappers>
</configuration>
<!-- 注意元素节点的顺序！顺序不对会报错 -->

properties复制代码url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8
driver=com.mysql.jdbc.Driver
username=root
password=123456

xml复制代码<properties resource="jdbc.properties"/>

<!--环境配置-->
<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${username}"/>
            <property name="password" value="${password}"/>
        </dataSource>
    </environment>
</environments

xml复制代码<!--环境配置-->
<environments default="development">
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8"/>
            <property name="username" value="root"/>
            <property name="password" value="123456"/>
        </dataSource>
    </environment>
</environments>

xml复制代码<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

xml复制代码<typeAliases>
    <typeAlias type="pojo.User" alias="User"/>
</typeAliases>

xml复制代码<typeAliases>
    <package name="pojo"/>
</typeAliases>

java复制代码import org.apache.ibatis.type.Alias;

@Alias("user")
public class User {

    private int id;
    private String name;
    private String password;

}

xml复制代码<!--环境配置-->
<environments default="development">
    
    <!--development环境-->
    <environment id="development">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${username}"/>
            <property name="password" value="${password}"/>
        </dataSource>
    </environment>

    <!--test-->
    <environment id="test">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${username}"/>
            <property name="password" value="${password}"/>
        </dataSource>
    </environment>
</environments>

xml复制代码<!-- 语法 -->
<transactionManager type="[ JDBC | MANAGED ]"/>

xml复制代码type="[UNPOOLED|POOLED|JNDI]"）

xml复制代码<mappers>

    <mapper resource="mapper/UserMapper.xml"/>

</mappers>

xml复制代码<!--需要配置文件名称和接口名称一致，并且位于同一目录下-->
<mappers>

    <mapper class="mapper.UserMapper"/>

</mappers>

xml复制代码<!--需要配置文件名称和接口名称一致，并且位于同一目录下-->
<mappers>

    <package name="mapper"/>
    
</mappers>

xml复制代码<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="mapper.UserMapper">

    <insert id="addUser" parameterType="pojo.User">
        insert into user(id, name, password)
        values (#{id}, #{name}, #{password})
    </insert>

</mapper>

c++复制代码// 一个简单的 C++ 程序来反转字符串
#include <bits/stdc++.h>
using namespace std;

// 反转字符串的函数
void reverseStr(string& str)
{
	int n = str.length();

	// 从两个角开始交换字符
	for (int i = 0; i < n / 2; i++)
		swap(str[i], str[n - i - 1]);
}

// 驱动程序
int main()
{
	string str = "haiyong";
	reverseStr(str);
	cout << str;
	return 0;
}

c++复制代码gnoyiah

c++复制代码// 反转 [begin, end] 中的元素
void reverse (BidirectionalIterator begin, 
BidirectionalIterator end);

c++复制代码//一个快速编写的程序，用于使用 reverse() 反转字符串
#include <bits/stdc++.h>
using namespace std;
int main()
{
	string str = "haiyong";

	// 反向 str[begin..end]
	reverse(str.begin(), str.end());

	cout << str;
	return 0;
}

c++复制代码gnoyiah

c++复制代码// C++程序打印一个字符串的反转
#include <bits/stdc++.h>
using namespace std;

// 反转字符串的函数
void reverse(string str)
{
for (int i=str.length()-1; i>=0; i--)
	cout << str[i];
}

// 驱动程序代码
int main(void)
{
	string s = "haiyong";
	reverse(s);
	return (0);
}

c++复制代码gnoyiah

c++复制代码// 获取const字符串反转的C++程序
#include <bits/stdc++.h>
using namespace std;

// 函数反转字符串并返回该字符串的反向字符串指针
char* reverseConstString(char const* str)
{
	// 查找字符串的长度
	int n = strlen(str);

	// 创建动态指针字符数组
	char *rev = new char[n+1];

	// 将字符串复制到 ptr 数组
	strcpy(rev, str);

	// 从两个角开始交换字符
	for (int i=0, j=n-1; i<j; i++,j--)
		swap(rev[i], rev[j]);	
	
	// 反转字符串的返回指针
	return rev;
}

// 驱动程序代码
int main(void)
{
	const char *s = "haiyong";
	printf("%s", reverseConstString(s));
	return (0);
}

c++复制代码gnoyiah

c++复制代码// 使用构造函数反转字符串的简单 C++ 程序
#include <bits/stdc++.h>
using namespace std;
int main(){

	string str = "haiyong";

	//反向迭代器的使用
	string rev = string(str.rbegin(),str.rend());

	cout<<rev<<endl;
	return 0;
}

c++复制代码gnoyiah

c++复制代码// 使用构造函数反转字符串的简单 C++ 程序
#include <bits/stdc++.h>
using namespace std;
int main(){

	string str = "haiyong";
	int n=str.length();
	//存储反向的临时字符串
	string rev;
	for(int i=n-1;i>=0;i--)
	rev.push_back(str[i]);

	cout<<rev<<endl;
	return 0;
}

c++复制代码gnoyiah