Fatal编程技术网
  • cplusplus/
  • C++ 我需要实现模板函数的专门化，该函数执行查找两个C样式字符串中较小的字符串的功能

C++ 我需要实现模板函数的专门化，该函数执行查找两个C样式字符串中较小的字符串的功能

c++ unit-testing templates

C++ 我需要实现模板函数的专门化，该函数执行查找两个C样式字符串中较小的字符串的功能,c++,unit-testing,templates,googletest,template-specialization,C++,Unit Testing,Templates,Googletest,Template Specialization,我写这段代码是为了实现针对上述问题的模板专门化，但代码不正确，因为它返回了我在顶部编写的模板函数的值，而没有检查我在下面编写的实际模板专门化函数以进行查找 两个C样式字符串中较小的一个。所有测试用例都是通过的，无论它们是对的还是错的。请帮助我解决这个问题。 这是我的密码 代码： #包括“pch.h” #包括 使用名称空间std； 模板 T较小（T a，T b）{ if（a

我写这段代码是为了实现针对上述问题的模板专门化，但代码不正确，因为它返回了我在顶部编写的模板函数的值，而没有检查我在下面编写的实际模板专门化函数以进行查找 两个C样式字符串中较小的一个。所有测试用例都是通过的，无论它们是对的还是错的。请帮助我解决这个问题。 这是我的密码

代码：

#包括“pch.h”
#包括
使用名称空间std；
模板
T较小（T a，T b）{
if（a0）
返回b；
否则如果（strcmp（a，b）<0）
返回a；
}
//测试（更小，TestName）{
//期望_EQ（'B'，较小（'a'，'B'））；
//期望_EQ（12，更小的（15，12））；
//期望_EQ（33.1，更小（33.1，44.2））；
////EXPECT\u TRUE（TRUE）；
//}
//测试（更小，测试名称为2）{
//期望（EQ（'B'，更小（'a'，'B'，'c'））；
//期望_EQ（12，更小（15，12，13））；
//期望_EQ（33.1，更小（33.1，44.2，44.5））；
////EXPECT\u TRUE（TRUE）；
//}
测试（更小，测试名称为3）{
字符串a=“ABC”；
字符串b=“DEF”；
期望_EQ（“ABC”，较小的（a，b））；
字符串c=“AB”；
字符串d=“DE”；
期望_EQ（“AB”，更小（c，d））；
字符串e=“Ba”；
字符串f=“Dd”；
期望_EQ（“Ba”，更小（e，f））；
}
只需像以前那样实现它

因为我不知道什么是
TEST
，所以我在另一个版本中更改了它

#包括
#包括
#包括
使用名称空间std；
模板
T较小（T a，T b）{
如果（a0？b:a；
}
模板
无效的期望值（T ans，T give）{
断言（ans==give）；
}
模板
void EXPECT_EQ（常量字符*ans，常量字符*give）{
断言（！strcmp（ans，give））；
}
int main（）{
const char*a=“ABC”；
常量char*b=“DEF”；
期望_EQ（“ABC”，较小的（a，b））；
常量字符*c=“AB”；
常量char*d=“DE”；
期望_EQ（“AB”，更小（c，d））；
常量char*e=“Ba”；
常量字符*f=“Dd”；
期望_EQ（“Ba”，更小（e，f））；
}
只需像以前那样实现它

因为我不知道什么是
TEST
，所以我在另一个版本中更改了它

#包括
#包括
#包括
使用名称空间std；
模板
T较小（T a，T b）{
如果（a0？b:a；
}
模板
无效的期望值（T ans，T give）{
断言（ans==give）；
}
模板
void EXPECT_EQ（常量字符*ans，常量字符*give）{
断言（！strcmp（ans，give））；
}
int main（）{
const char*a=“ABC”；
常量char*b=“DEF”；
期望_EQ（“ABC”，较小的（a，b））；
常量字符*c=“AB”；
常量char*d=“DE”；
期望_EQ（“AB”，更小（c，d））；
常量char*e=“Ba”；
常量字符*f=“Dd”；
期望_EQ（“Ba”，更小（e，f））；
}

它对我很有用。
#包括“pch.h”
#包括
#包括
#包括
使用名称空间std；
模板
T较小（T a，T b）{
如果（a0？b:a；
}
//模板
//无效的期望值（T ans，T give）{
//断言（ans==give）；
//}
//
//模板
//void EXPECT_EQ（常量字符*ans，常量字符*give）{
//断言（！strcmp（ans，give））；
//}
测试（更小，测试名称为3）{
const char*a=“ABC”；
常量char*b=“DEF”；
常数char*aa=更小（a，b）；
期望q（a，aa）；
常量字符*c=“AB”；
常量char*d=“DE”；
const char*dd=更小（c，d）；
期望（c，dd）；
常量char*e=“Ba”；
常量字符*f=“Dd”；
常数char*ff=更小（e，f）；
期望（e，ff）；
}

它对我很有用。
#包括“pch.h”
#包括
#包括
#包括
使用名称空间std；
模板
T较小（T a，T b）{
如果（a0？b:a；
}
//模板
//无效的期望值（T ans，T give）{
//断言（ans==give）；
//}
//
//模板
//void EXPECT_EQ（常量字符*ans，常量字符*give）{
//断言（！strcmp（ans，give））；
//}
测试（更小，测试名称为3）{
const char*a=“ABC”；
常量char*b=“DEF”；
常数char*aa=更小（a，b）；
期望q（a，aa）；
常量字符*c=“AB”；
常量char*d=“DE”；
const char*dd=更小（c，d）；
期望（c，dd）；
常量char*e=“Ba”；
常量字符*f=“Dd”；
常数char*ff=更小（e，f）；
期望（e，ff）；
}
Hey，参见
EXPECT_EQ（“ABC”，较小的（a，b））std:：string
类型。也许你应该实现
std:：string
版本专业化。嗨@SHP，现在我知道我创建的那些测试用例是错误的。我传递的参数类型和代码都有问题。此外，我想说的是，要求与我上面提到的相同。嘿，请参见
EXPECT_EQ（“ABC”，更小的（a，b））std:：string
类型。也许您应该实现
std:：string
version specialization.Hi@S 
#include "pch.h"
#include<iostream>
using namespace std;

template<typename T>
T smaller(T a, T b) {
    if (a < b)
        return a;
    return b;
}
//template<typename T>
//T smaller(T a, T b, T c)
//{
//  if (a < b && a < c)
//      return a;
//  else if (b < c && b < a)
//      return b;
//  else if (c < a && c < b)
//      return c;
//  
//}
template <>
const char* smaller<const char *>(const char *a,const char *b)
{
    //int strcmp ( const char * str1, const char * str2 );
    if (strcmp(a, b) == 0)
        return "0";
    else if (strcmp(a, b) > 0)
        return b;
    else if (strcmp(a, b) < 0)
        return a;
    
}
//TEST(smaller, TestName) {
//  EXPECT_EQ('B', smaller('a','B'));
//  EXPECT_EQ(12, smaller(15, 12));
//  EXPECT_EQ(33.1, smaller(33.1, 44.2));
//  //EXPECT_TRUE(true);
//}

//TEST(smaller, TestName_2) {
//  EXPECT_EQ('B', smaller('a', 'B','c'));
//  EXPECT_EQ(12, smaller(15, 12,13));
//  EXPECT_EQ(33.1, smaller(33.1, 44.2,44.5));
//  //EXPECT_TRUE(true);
//}

TEST(smaller, TestName_3) {
    string a = "ABC";
    string b = "DEF";
    EXPECT_EQ("ABC", smaller(a, b));
    string c = "AB";
    string d = "DE";
    EXPECT_EQ("AB", smaller(c, d));
    string e = "Ba";
    string f = "Dd";
    EXPECT_EQ("Ba", smaller(e, f));
}

it works for me. 

#include"pch.h"
#include <cassert>
#include <cstring>
#include <iostream>
using namespace std;

template <typename T>
T smaller(T a, T b) {
    if (a < b) return a;
    return b;
}

template <>
const char* smaller<const char*>(const char* a, const char* b) {
    int ans = strcmp(a, b);
    if (ans == 0) {
        return "0";
    }
    return ans > 0 ? b : a;
}

//template <typename T>
//void EXPECT_EQ(T ans, T give) {
//    assert(ans == give);
//}
//
//template <>
//void EXPECT_EQ(const char* ans, const char* give) {
//    assert(!strcmp(ans, give));
//}

TEST(smaller, TestName_3) {
    const char* a = "ABC";
    const char* b = "DEF";
    const char* aa = smaller(a, b);
    EXPECT_EQ(a, aa);
    const char* c = "AB";
    const char* d = "DE";
    const char* dd = smaller(c, d);
    EXPECT_EQ(c, dd);
    const char* e = "Ba";
    const char* f = "Dd";
    const char* ff = smaller(e, f);
    EXPECT_EQ(e, ff);
}