在我的程序中，我有一个“服务器地址”列表，格式如下：
host[:port]
此处的括号表示port是可选的。
host可以是主机名，IPv4或IPv6地址（可能采用“括号括起”表示法。）port，如果存在，可以是数字端口号或服务字符串（如：“http”或“ssh”）。如果port存在且host是IPv6地址，则host 必须采用“括号括起”表示法（示例：{{1} }）
以下是一些有效的例子：
[::1]一个无效的例子：
localhost
localhost:11211
127.0.0.1:http
[::1]:11211
::1
[::1]
我的目标是将这些条目分为两部分（显然是::1:80 // Invalid: Is this the IPv6 address ::1:80 and a default port, or the IPv6 address ::1 and the port 80 ?
::1:http // This is not ambigous, but for simplicity sake, let's consider this is forbidden as well.
和host）。我不在乎port或host是否无效，只要它们不包含非括号内的port（:可以{ {1}}，它将在下一个过程中被拒绝）;我只想将这两部分分开，或者如果没有290.234.34.34.5部分，则以某种方式知道。
我试图用host做点什么，但我所遇到的一切看起来都很糟糕而且不是很优雅。
您将如何在port中执行此操作？
我不介意std::stringstream中的答案，但C++是首选。任何C解决方案也是受欢迎的。
谢谢。
答案 0 :(得分：9)
你看过boost::spirit了吗？但是，对你的任务来说可能有些过分。
答案 1 :(得分：5)
这是一个简单的类，它使用boost :: xpressive来验证IP地址的类型，然后你可以解析其余部分来获得结果。
用法：
const std::string ip_address_str = "127.0.0.1:3282";
IpAddress ip_address = IpAddress::Parse(ip_address_str);
std::cout<<"Input String: "<<ip_address_str<<std::endl;
std::cout<<"Address Type: "<<IpAddress::TypeToString(ip_address.getType())<<std::endl;
if (ip_address.getType() != IpAddress::Unknown)
{
std::cout<<"Host Address: "<<ip_address.getHostAddress()<<std::endl;
if (ip_address.getPortNumber() != 0)
{
std::cout<<"Port Number: "<<ip_address.getPortNumber()<<std::endl;
}
}
类的头文件IpAddress.h
#pragma once
#ifndef __IpAddress_H__
#define __IpAddress_H__
#include <string>
class IpAddress
{
public:
enum Type
{
Unknown,
IpV4,
IpV6
};
~IpAddress(void);
/**
* \brief Gets the host address part of the IP address.
* \author Abi
* \date 02/06/2010
* \return The host address part of the IP address.
**/
const std::string& getHostAddress() const;
/**
* \brief Gets the port number part of the address if any.
* \author Abi
* \date 02/06/2010
* \return The port number.
**/
unsigned short getPortNumber() const;
/**
* \brief Gets the type of the IP address.
* \author Abi
* \date 02/06/2010
* \return The type.
**/
IpAddress::Type getType() const;
/**
* \fn static IpAddress Parse(const std::string& ip_address_str)
*
* \brief Parses a given string to an IP address.
* \author Abi
* \date 02/06/2010
* \param ip_address_str The ip address string to be parsed.
* \return Returns the parsed IP address. If the IP address is
* invalid then the IpAddress instance returned will have its
* type set to IpAddress::Unknown
**/
static IpAddress Parse(const std::string& ip_address_str);
/**
* \brief Converts the given type to string.
* \author Abi
* \date 02/06/2010
* \param address_type Type of the address to be converted to string.
* \return String form of the given address type.
**/
static std::string TypeToString(IpAddress::Type address_type);
private:
IpAddress(void);
Type m_type;
std::string m_hostAddress;
unsigned short m_portNumber;
};
#endif // __IpAddress_H__
该类的源文件，IpAddress.cpp
#include "IpAddress.h"
#include <boost/xpressive/xpressive.hpp>
namespace bxp = boost::xpressive;
static const std::string RegExIpV4_IpFormatHost = "^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]+(\\:[0-9]{1,5})?$";
static const std::string RegExIpV4_StringHost = "^[A-Za-z0-9]+(\\:[0-9]+)?$";
IpAddress::IpAddress(void)
:m_type(Unknown)
,m_portNumber(0)
{
}
IpAddress::~IpAddress(void)
{
}
IpAddress IpAddress::Parse( const std::string& ip_address_str )
{
IpAddress ipaddress;
bxp::sregex ip_regex = bxp::sregex::compile(RegExIpV4_IpFormatHost);
bxp::sregex str_regex = bxp::sregex::compile(RegExIpV4_StringHost);
bxp::smatch match;
if (bxp::regex_match(ip_address_str, match, ip_regex) || bxp::regex_match(ip_address_str, match, str_regex))
{
ipaddress.m_type = IpV4;
// Anything before the last ':' (if any) is the host address
std::string::size_type colon_index = ip_address_str.find_last_of(':');
if (std::string::npos == colon_index)
{
ipaddress.m_portNumber = 0;
ipaddress.m_hostAddress = ip_address_str;
}else{
ipaddress.m_hostAddress = ip_address_str.substr(0, colon_index);
ipaddress.m_portNumber = atoi(ip_address_str.substr(colon_index+1).c_str());
}
}
return ipaddress;
}
std::string IpAddress::TypeToString( Type address_type )
{
std::string result = "Unknown";
switch(address_type)
{
case IpV4:
result = "IP Address Version 4";
break;
case IpV6:
result = "IP Address Version 6";
break;
}
return result;
}
const std::string& IpAddress::getHostAddress() const
{
return m_hostAddress;
}
unsigned short IpAddress::getPortNumber() const
{
return m_portNumber;
}
IpAddress::Type IpAddress::getType() const
{
return m_type;
}
我只设置了IPv4的规则，因为我不知道IPv6的正确格式。但我很确定实现它并不难。 Boost Xpressive只是一个基于模板的解决方案，因此不需要将任何.lib文件编译到你的exe中，我认为这是一个加号。
顺便说一下，简单地打破正则表达式的格式......
^ =字符串的开头
$ =字符串结束
[] =一组可以出现的字母或数字
[0-9] = 0到9之间的任何单位数字
[0-9] + = 0到9之间的一个或多个数字
'。'对正则表达式有特殊意义，但由于我们的格式在ip-address格式中有1个点，我们需要指定我们想要一个'。'使用'\。'在数字之间。但由于C ++需要'\'的转义序列，我们必须使用“\\。”
？ =可选组件
因此，简而言之，“^ [0-9] + $”代表一个正则表达式，对于整数是正确的。
“^ [0-9] + \。$”表示以“。”结尾的整数
“^ [0-9] + \。[0-9]？$”是以“。”结尾的整数。或小数
对于整数或实数，正则表达式将是“^ [0-9] +（\。[0-9] *）？$”。
RegEx是2到3个数字之间的整数“^ [0-9] {2,3} $”。
现在分解ip地址的格式：
"^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]+(\\:[0-9]{1,5})?$"
这与以下内容同义：“^ [0-9] {1,3} \。[0-9] {1,3} \。[0-9] {1,3} \。[0-9 ] +（\：[0-9] {1,5}）？$“，表示：
[start of string][1-3 digits].[1-3 digits].[1-3 digits].[1-3 digits]<:[1-5 digits]>[end of string]
Where, [] are mandatory and <> are optional
第二个RegEx比这更简单。它只是一个字母数字值后跟一个可选的冒号和端口号的组合
顺便说一下，如果您想测试RegEx，可以使用this site
修改：我没注意到您可选择使用http而不是端口号。为此，您可以将表达式更改为：
"^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]+(\\:([0-9]{1,5}|http|ftp|smtp))?$"
这接受如下格式：
127.0.0.1
127.0.0.1:3282
127.0.0.1:http
217.0.0.1:ftp
18.123.2.1:smtp
答案 2 :(得分：4)
我参加聚会迟到了，但我正在谷歌上搜索如何做到这一点。 Spirit 和 C++ 成长了很多，所以让我补充一下 2021 年的情况：
#include <fmt/ranges.h>
#include <boost/spirit/home/x3.hpp>
#include <boost/fusion/adapted/std_tuple.hpp>
auto parse_server_address(std::string_view address_spec,
std::string_view default_service = "https")
{
using namespace boost::spirit::x3;
auto service = ':' >> +~char_(":") >> eoi;
auto host = '[' >> *~char_(']') >> ']' // e.g. for IPV6
| raw[*("::" | (char_ - service))];
std::tuple<std::string, std::string> result;
parse(begin(address_spec), end(address_spec),
expect[host >> (service | attr(default_service))], result);
return result;
}
int main() {
for (auto input : {
"localhost",
"localhost:11211",
"127.0.0.1:http",
"[::1]:11211",
"::1", "[::1]",
"::1:80", // Invalid: Is this the IPv6 address ::1:80 and a default
// port, or the IPv6 address ::1 and the port 80 ?
"::1:http", // This is not ambigous, but for simplicity sake, let's
// consider this is forbidden as well.
})
{
// auto [host, svc] = parse_server_address(input);
fmt::print("'{}' -> {}\n", input, parse_server_address(input));
}
}
打印
'localhost' -> ("localhost", "https")
'localhost:11211' -> ("localhost", "11211")
'127.0.0.1:http' -> ("127.0.0.1", "http")
'[::1]:11211' -> ("::1", "11211")
'::1' -> ("::1", "https")
'[::1]' -> ("::1", "https")
'::1:80' -> ("::1", "80")
'::1:http' -> ("::1", "http")
验证/解析地址。解析是 100% 不变的，只是使用 Asio 来解析结果，同时验证它们：
#include <boost/asio.hpp>
#include <iostream>
#include <iomanip>
using boost::asio::ip::tcp;
using boost::asio::system_executor;
using boost::system::error_code;
int main() {
tcp::resolver r(system_executor{});
error_code ec;
for (auto input : {
"localhost",
"localhost:11211",
"127.0.0.1:http",
"[::1]:11211",
"::1", "[::1]",
"::1:80", // Invalid: Is this the IPv6 address ::1:80 and a default
// port, or the IPv6 address ::1 and the port 80 ?
"::1:http", // This is not ambigous, but for simplicity sake, let's
// consider this is forbidden as well.
"stackexchange.com",
"unknown-host.xyz",
})
{
auto [host, svc] = parse_server_address(input);
for (auto&& endpoint : r.resolve({host, svc}, ec)) {
std::cout << input << " -> " << endpoint.endpoint() << "\n";
}
if (ec.failed()) {
std::cout << input << " -> unresolved: " << ec.message() << "\n";
}
}
}
打印（有限网络Live On Wandbox和Coliruhttp://coliru.stacked-crooked.com/a/497d8091b40c9f2d）
localhost -> 127.0.0.1:443
localhost:11211 -> 127.0.0.1:11211
127.0.0.1:http -> 127.0.0.1:80
[::1]:11211 -> [::1]:11211
::1 -> [::1]:443
[::1] -> [::1]:443
::1:80 -> [::1]:80
::1:http -> [::1]:80
stackexchange.com -> 151.101.129.69:443
stackexchange.com -> 151.101.1.69:443
stackexchange.com -> 151.101.65.69:443
stackexchange.com -> 151.101.193.69:443
unknown-host.xyz -> unresolved: Host not found (authoritative)
答案 3 :(得分：3)
std::string host, port;
std::string example("[::1]:22");
if (example[0] == '[')
{
std::string::iterator splitEnd =
std::find(example.begin() + 1, example.end(), ']');
host.assign(example.begin(), splitEnd);
if (splitEnd != example.end()) splitEnd++;
if (splitEnd != example.end() && *splitEnd == ':')
port.assign(splitEnd, example.end());
}
else
{
std::string::iterator splitPoint =
std::find(example.rbegin(), example.rend(), ':').base();
if (splitPoint == example.begin())
host = example;
else
{
host.assign(example.begin(), splitPoint);
port.assign(splitPoint, example.end());
}
}
答案 4 :(得分：0)
如上所述，Boost.Spirit.Qi可以解决这个问题。
如上所述，它真的有点过分了。
const std::string line = /**/;
if (line.empty()) return;
std::string host, port;
if (line[0] == '[') // IP V6 detected
{
const size_t pos = line.find(']');
if (pos == std::string::npos) return; // Error handling ?
host = line.substr(1, pos-1);
port = line.substr(pos+2);
}
else if (std::count(line.begin(), line.end(), ':') > 1) // IP V6 without port
{
host = line;
}
else // IP V4
{
const size_t pos = line.find(':');
host = line.substr(0, pos);
if (pos != std::string::npos)
port = line.substr(pos+1);
}
我真的不认为这需要一个解析库，因为:的使用过载，它可能无法提高可读性。
现在我的解决方案当然不是完美的，例如可以想知道它的效率......但我认为这已经足够了，至少你不会失去下一个维护者，因为根据经验，Qi表达式可以是清楚！
答案 5 :(得分：0)
#pragma once
#ifndef ENDPOINT_HPP
#define ENDPOINT_HPP
#include <string>
using std::string;
struct Endpoint {
string
Host,
Port;
enum : char {
V4,
V6
} Type = V4;
__inline Endpoint(const string& text) {
bind(text);
}
private:
void __fastcall bind(const string& text) {
if (text.empty())
return;
auto host { text };
string::size_type bias = 0;
constexpr auto NONE = string::npos;
while (true) {
bias = host.find_first_of(" \n\r\t", bias);
if (bias == NONE)
break;
host.erase(bias, 1);
}
if (host.empty())
return;
auto port { host };
bias = host.find(']');
if (bias != NONE) {
host.erase(bias);
const auto skip = text.find('[');
if (skip == NONE)
return;
host.erase(0, skip + 1);
Type = V6;
++bias;
}
else {
bias = host.find(':');
if (bias == NONE)
port.clear();
else {
const auto next = bias + 1;
if (host.length() == next)
return;
if (host[next] == ':') {
port.clear();
Type = V6;
}
else if (! bias)
host.clear();
else
host.erase(bias);
}
}
if (! port.empty())
Port = port.erase(0, bias + 1);
if (! host.empty())
Host = host;
}
};
#endif // ENDPOINT_HPP
答案 6 :(得分：-3)
如果您通过字符串或C ++中的字符数组获取端口和主机;你可以得到字符串的长度。执行for循环直到字符串结束，直到找到单个冒号本身并将该字符串拆分为该位置的两个部分。
for (int i=0; i<string.length; i++) {
if (string[i] == ':') {
if (string[i+1] != ':') {
if (i > 0) {
if (string[i-1] != ':') {
splitpoint = i;
} } } } }
只是一个有点深刻的建议，我确信有一种更有效的方式，但希望这会有所帮助， 大风