alfabetisk vector-sortering med std::string

Hvis du altid vil bruge den samme sortering af din class, er det letteste at lave en global < operator for din class, evt som en friend, f.ex:

bool operator < (const EnKlasse& aLhs, const EnKlasse& aRhs)
{
   return aLhs._name < aRhs._name;
}

Så sorterer du bare med:
std::sort(vec.begin(), vec.end());

Ja det lyder nemt nok , men hvad med den alfabetiske del?
En string sorteres jo efter bogstavets ASCII værdi, eller noget i den stil, så store bogstaver altid kommer før små, og altså ikke i den rækkefølge man ville forvente i en ordbog.

Du kan bruge:

bool operator < (const EnKlasse& aLhs, const EnKlasse& aRhs)
{
   return stricmp(aLhs._name.c_str(), aRhs._name.c_str()) < 0;
}

Hvis du mener at det er bedre.

Ja, nu står de opstillet alfabetisk, men prioriteten af store bogstaver er ikke højere end for små. Findes der ikke en sammenlignings-funktion, som kan opstille store bogstaver FØR små, og samtidig danne en alfabetisk orden?
Eller er man nød til selv at skrive en?

Jeg forstår ikke. Hvad er problemet?

Den første tog hensyn til store og små bogstaver, og det var et problem, den anden gør ikke, og det er også et problem

Beklager hvis jeg ikke har udtrykt meg klart nok.
Det jeg mente var at der FØRST blev taget hensyn til alfabetisk rækkefølge, og DEREFTER til store/små bogstaver.

#include <iostream>
#include <vector>
#include <string>

class EnKlasse {
public:
       EnKlasse(std::string name):
                            _name(name) {}
       
       std::string _name;
       std::string _data;
};

bool operator<(const EnKlasse& enKlasse1, const EnKlasse& enKlasse2)
{
     return enKlasse1._name<enKlasse2._name;
}
     

int main()
{
    std::vector<EnKlasse> vec;
    vec.push_back(EnKlasse("bjørn"));
    vec.push_back(EnKlasse("Abe"));
    vec.push_back(EnKlasse("abe"));
    vec.push_back(EnKlasse("Bjørn"));
    
    std::sort(vec.begin(), vec.end());
    
    std::cout<<vec[0]._name<<std::endl;
    std::cout<<vec[1]._name<<std::endl;
    std::cout<<vec[2]._name<<std::endl;
    std::cout<<vec[3]._name<<std::endl;

    system("pause");
    
    return 0;
}   

I ovenstående rækkefølge blicer output:
Abe
Bjørn
abe
bjørn

#include <iostream>
#include <string>
#include <vector>

class EnKlasse {
public:
       EnKlasse(std::string s): _name(s){}
       std::string _name;
};
       
bool operator < (const EnKlasse& aLhs, const EnKlasse& aRhs)
{
   return stricmp(aLhs._name.c_str(), aRhs._name.c_str()) < 0;
}

int main()
{
    std::vector<EnKlasse> vec;
    vec.push_back(EnKlasse("bjørn"));
    vec.push_back(EnKlasse("Abe"));
    vec.push_back(EnKlasse("Bjørn"));
    vec.push_back(EnKlasse("abe"));
    std::sort(vec.begin(), vec.end());
    std::cout<<vec[0]._name<<std::endl;
    std::cout<<vec[1]._name<<std::endl;
    std::cout<<vec[2]._name<<std::endl;
    std::cout<<vec[3]._name<<std::endl;
 
    system("pause");   
    return 0;
}

Ovenstående giver output:
Abe
abe
bjørn
Bjørn

Det ønskede output er dog:
Abe
abe
Bjørn
bjørn

Altså alfabetisk rækkefølge, hvor store bogstaver kommer før små.
Håber det er til at forstå ellers så bare spørg

Jeg tror at du er nød til at lave din egen algoritme til sammenligning. Der er vist ikke nogen af standard algoritmerne der virker på den måde som du vil have dem til.