How do I declare a function "friend" to a class if the class is inside a namespace and the function is in the global scope?
#Classes and friends
velvet plinth
midnight bobcatBOT
hazy garden
you need to have a forward declaration of the function outside of the class then
velvet plinth
inside the namespace?
silver tusk
can you not explicitly specify the scope of friend function?
friend void ::foo(); like this?
silver tusk
Hmm I see
velvet plinth
the friend function takes a reference to an object of the class as a parameter tho
error: 'string' does not name a type
std::ostream& operator<<(std::ostream& out, const string& s);
then you also have to forward declare that 😄
velvet plinth
where string is the class name
hazy garden
namespace A {
struct Example;
}
namespace B {
void foo(const A::Example&);
}
namespace A {
struct Example {
friend void B::foo(const Example&);
private:
int i = 123;
};
}
do the members of Example need to be forward declared as well?
hazy garden
no, you can't even do that
velvet plinth
no, you can't even do that
I'm not sure why this isn't working (ignore the fact that the buffer is not null terminated)
#include <iostream>
namespace user{
class string;
}
std::ostream& operator<<(std::ostream& out, const user::string& s);
namespace user{
class string{
private:
char* m_Buffer;
unsigned int m_size;
public:
string(const char* string){
int count = 0;
while(string[count] != '\0'){
count++;
}
m_size = count;
m_Buffer = new char[m_size];
for(int i = 0; i < m_size; i++){
m_Buffer[i] = string[i];
}
}
friend std::ostream& operator<<(std::ostream& out, const string& s);
};
}
std::ostream& operator<<(std::ostream& out, const string& s){
out << s.m_Buffer;
return out;
}
using namespace user;
int main(){
string s = string("Hello");
std::cout << s << std::endl;
}
oh you want to define a steam operator?
that doesn't have to be done like this
there's no need for that to be in the global namespace
you can define that right in the class if you like:
struct Example {
friend std::ostream& operator<<(std::ostream& out, const Example& e) {
return out << e.whatever;
}
};
ah yea that's possible 😅 but I just wanted to learn how it can be done outside, it works if I don't use a namespace but not sure how to get it working when the class is inside one
hazy garden
then you put the operator definition inside the namespace as well
it will be found there because of ADL (argument dependent lookup)
velvet plinth
so you can't access functions outside a namespace from inside it?
hazy garden
huh?
hazy garden
I'm not sure why this isn't working (ignore the fact that the buffer is not null...
;compile
vivid chasmBOT
hazy garden
you have to spell it user::string outside of the namespace
-std::ostream& operator<<(std::ostream& out, const string& s){
+std::ostream& operator<<(std::ostream& out, const user::string& s){
out << s.m_Buffer;
return out;
}
#include <iostream>
namespace user{
class string;
}
std::ostream& operator<<(std::ostream& out, const user::string& s);
namespace user{
class string{
private:
char* m_Buffer;
unsigned int m_size;
public:
string(const char* string){
int count = 0;
while(string[count] != '\0'){
count++;
}
m_size = count;
m_Buffer = new char[m_size];
for(int i = 0; i < m_size; i++){
m_Buffer[i] = string[i];
}
}
friend std::ostream& operator<<(std::ostream& out, const user::string& s);
};
}
std::ostream& operator<<(std::ostream& out, const user::string& s){
out << s.m_Buffer;
return out;
}
using namespace user;
int main(){
string s = string("Hello");
std::cout << s << std::endl;
}
;compile
vivid chasmBOT
hazy garden
and then like @silver tusk said you have to tell it you're talking about operator<< in the global namespace
because by default, a friend declaration puts/assumes the namespace the class is in
-friend std::ostream& operator<<(std::ostream& out, const string& s);
+friend std::ostream& ::operator<<(std::ostream& out, const string& s);
Ah, this works, thank you
but the global scope resolution :: should only be put in the declaration inside the class?
putting it outside as well gives me:
error: explicit qualification in declaration of 'std::ostream& operator<<(std::ostream&, const user::string&)'
std::ostream& ::operator<<(std::ostream& out, const user::string& s);
why is that?
it seems like it should be a warning?
silver tusk
You dont have to put it on the declaration outside, since the scope in which it is being declared is already taken into account.
If the declaration is present in global scope then it means that the function is present in global scope, and it shall be defined there.
velvet plinth
You dont have to put it on the declaration outside, since the scope in which it ...
but if I do this inside a namespace it works?
why does the compiler give an error tho? it doesn't like much of a deal
hazy garden
a friend declaration is a bit special
but other declarations just... cannot be qualified, in general
you can't be in namespace A and declare something in namespace B
(well except specializations :vv )
velvet plinth
you can't be in namespace A and declare something in namespace B
but here we're in the global scope using :: on an operator in the global scope?
hazy garden
why would C++ add rules to allow this special case of a qualified declaration that has no effect 😄
velvet plinth
yea makes sense, thank you & @silver tusk for you time and help
midnight bobcatBOT
velvet plinth
!solved