ошибки с видимостью - C/C++

Всем привет

есть класс хочу в нем сделать видим символ string чтобы не писать вечно std::string

делаю так

struct test
{
    using std::string;
    void f(const string& var)
    {
    }
};

получаю

error C2886: 'std::string' : symbol cannot be used in a member using-declaration

делаю так

struct test
{
    using namespace std;
    void f(const string& var)
    {
    }
};

получаю

error C2059: syntax error : 'namespace'

в чем проблема и как добиться желаемого ?

struct test
{
    typedef std::string string;
    void f(const string& var)
    {
    }
};

единственный вариант ?

почему не работают два первых варианта ?

а как быть если символ это шаблон ? например

struct test
{
    typedef msclr::interop::marshal_as marshal_as;
};

выдает

error C2146: syntax error : missing ';' before identifier 'marshal_as'

как быть в этом случае ?

можно как нить так указать ?

struct test
{
    template<class any>
    typedef msclr::interop::marshal_as<any> marshal_as<any>;
};

как быть ?

спасибо

вот например marshal_as это шаблон и использовать я его хочу так

struct test
{
    typedef msclr::interop::marshal_as marshal_as;
    void f(String^ key)
    {
        doSmth(marshal_as<std::string>(key));
    }
};

но typedef в таком виде не работает почему то ...

как быть ?

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>вот например marshal_as это шаблон и использовать я его хочу так
[...]
J>но typedef в таком виде не работает почему то ...
J>как быть ?

Выбирай:

#include <vector>

struct T
{
   template<typename Elem>
   using V = std::vector<Elem>;
   
   template<typename Elem>
   struct W
   {
      typedef std::vector<Elem> type;
   };
   
   template<template<typename> class T,typename Elem>
   struct B
   {
      typedef T<Elem> type;
   };

   V<int> vi;
   W<int>::type wi;
   B<V,int>::type bi;
};

оказывается marshal_as определен как шаблонная функция ...

namespace msclr
{
    namespace interop
    {
        template<class _To_Type>
        inline _To_Type marshal_as(...)
        {
            return ...;
        }
    }
}

как мне сделать видимым эту функцию только в классе чтоб обращаться к ней можно было не указывая
неймспейсы постоянно

struct test
{
    typedef ... marshal_as;
    void f(String^ key)
    {
        doSmth(marshal_as<std::string>(key));
    }
};

Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>Выбирай:

Вдогонку:

#include <vector>
#include <boost/mpl/quote.hpp>
#include <boost/mpl/apply.hpp>
#include <boost/mpl/lambda.hpp>

struct T
{
    typedef boost::mpl::quote2< std::vector > q;
    typedef boost::mpl::lambda< std::vector<boost::mpl::_> > l;
    typedef boost::mpl::lambda< std::vector<boost::mpl::_> >::type ll;

    boost::mpl::apply< q,int,std::allocator<int> > qi;
    q::apply< int,std::allocator<int> > qi2;

    boost::mpl::apply< l,int > li;
    ll::apply<int> lli;
};

int main(){}

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>как мне сделать видимым эту функцию только в классе чтоб обращаться к ней можно было не указывая
J>неймспейсы постоянно

1. using declaration/directive, namespace alias могут быть внутри функций:

#include <cmath>

int main()
{
   using std::sin;
   namespace s = std;
   using namespace std;
}

2. напиши класс wrapper с шаблонным operator().

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>оказывается marshal_as определен как шаблонная функция ...

J>

J>namespace msclr
J>{
J>    namespace interop
J>    {
J>        template<class _To_Type>
J>        inline _To_Type marshal_as(...)
J>        {
J>            return ...;
J>        }
J>    }
J>}
J>

J>как мне сделать видимым эту функцию только в классе чтоб обращаться к ней можно было не указывая
J>неймспейсы постоянно

J>

J>struct test
J>{
J>    typedef ... marshal_as;
J>    void f(String^ key)
J>    {
J>        doSmth(marshal_as<std::string>(key));
J>    }
J>};
J>

Так не нравится?:

struct test
{
    f(String^ key)
    {
        doSmth(marshal_as<std::string>(key));
    }

private:

    template<class _To_Type, class _From_Type>
    _To_Type marshal_as(const _From_Type& from)
    {
       return msclr::interop::marshal_as<_To_Type>(from);
    }
};

Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>1. using declaration/directive, namespace alias могут быть внутри функций

да но тогда придется внутри каждой функции это писать... не очень удобно...

EP>2. напиши класс wrapper с шаблонным operator().

получилось через функцию прослойку

struct test
{
    template<class _To_Type, class _From_Type>
    _To_Type marshal(const _From_Type& r)
    {
        return msclr::interop::marshal_as<_To_Type>(r);
    }

    void f(String^ key)
    {
        doSmth(marshal<std::string>(key));
    }
};

но все равно странно что проще никак нельзя сделать...

Здравствуйте, rg45, Вы писали:

R>Так не нравится?:
R>

R>struct test
R>{
R>    f(String^ key)
R>    {
R>        doSmth(marshal_as<std::string>(key));
R>    }

R>private:

R>    template<class _To_Type, class _From_Type>
R>    _To_Type marshal_as(const _From_Type& from)
R>    {
R>       return msclr::interop::marshal_as<_To_Type>(from);
R>    }
R>};
R>

да это похоже меньшее из зол...

но странно что не существует простого способа добавить имя marshal_as в неймспейс класса...

Здравствуйте, Evgeny.Panasyuk, Вы писали:

EP>2. напиши класс wrapper с шаблонным operator().

но ведь тогда придется или создавать инстанс

marshal m;
m.operator()<std::string>(key);

или вызывать как то так

marshal().operator()<std::string>(key);

или я Вас не понял

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>да это похоже меньшее из зол...

J>но странно что не существует простого способа добавить имя marshal_as в неймспейс класса...

Тут возникает ряд тонких вопросов, ответы на которые не очень очевидны. Когда мы используем using declaration или using directive в каком-либо пространстве имен, мы тем самым добавляем в это пространство имен новые имена и делаем их доступными через это пространство имен так, как-будто они в нем определены:

namespace ns1 {

using namespace ns2; // using directive
using ns3::foo; // using declaration

} // namespace ns1

 . . .
// somewhere below:

ns1::foo();
ns1::bar(); // bar became from ns2

А вот теперь, что если вместо пространства имен ns1 мы использует класс (структуру)? Как должны сочетаться друг с другом имена, веденные из из базовых классов и из внешних пространств имен? Должны ли они быть видны за пределами структуры, как это было в случае с пространством имен? Если мы разрешаем использование директивы using (импорт всего пространства имен) для пространств имен, то почему не разрешаем для базовых классов? Как управлять спецификацией доступа к введенным именам (private/propected/public)? Если можно импортировать имена из пространства имен в класс, то, наверное, можно импортировать имена из класса в пространство имен? Также возникают некоторые вопросы, касающиеся ADL. Я думаю, что просто эти возможности сочли не очень востребованными и не очень критичными и предпочли не заморачиваться поиском ответов на подобные вопросы.

Здравствуйте, jyuyjiyuijyu, Вы писали:

J>

J>struct test
J>{
J>    using std::string;
J>    void f(const string& var)
J>    {
J>    }
J>};
J>

J>как быть ?

Прямо вроде как нельзя, но можно попробовать слегка хаккернуть...

namespace using_std {
    using namespace std;
    struct test
    {
        void f(const string& var)
        {
        }
    };
}
using using_std::test;

test().f( "bla-bla-bla" );

J>спасибо
Для "спасибо" тут есть кнопки...

Здравствуйте, rg45, Вы писали:

R>Если можно импортировать имена из пространства имен в класс, то, наверное, можно импортировать имена из класса в пространство имен? Также возникают некоторые вопросы, касающиеся ADL. Я думаю, что просто эти возможности сочли не очень востребованными и не очень критичными и предпочли не заморачиваться поиском ответов на подобные вопросы.

Если честно, мне не ясно, почему в С++ вообще нельзя управлять видимостью имён в частности и составом скоупов вообще. Почему всё делается как-то хитро-неявно? Зачем это всё надо? Я не понимаю...

Здравствуйте, Erop, Вы писали:

R>>Если можно импортировать имена из пространства имен в класс, то, наверное, можно импортировать имена из класса в пространство имен? Также возникают некоторые вопросы, касающиеся ADL. Я думаю, что просто эти возможности сочли не очень востребованными и не очень критичными и предпочли не заморачиваться поиском ответов на подобные вопросы.

E>Если честно, мне не ясно, почему в С++ вообще нельзя управлять видимостью имён в частности и составом скоупов вообще. Почему всё делается как-то хитро-неявно? Зачем это всё надо? Я не понимаю...

Мне сложно сказать, послушать бы того, кто это проектировал. Вероятно, они рассматривали какие-то юзкейсы, пытались предотвратить какие-то сложности...

Здравствуйте, Erop, Вы писали:

E>Прямо вроде как нельзя, но можно попробовать слегка хаккернуть...

namespace using_std {
E>    using namespace std;
E>    struct test
E>    {
E>        void f(const string& var)
E>        {
E>        }
E>    };
E>}
E>using using_std::test;

E>test().f( "bla-bla-bla" );

да интересное решение ...

	От:	jyuyjiyuijyu
	Дата:	06.03.13 07:46
	Оценка:

	От:	jyuyjiyuijyu
	Дата:	06.03.13 08:01
	Оценка:

	От:	Evgeny.Panasyuk
	Дата:	06.03.13 08:34
	Оценка:

	От:	jyuyjiyuijyu
	Дата:	06.03.13 08:38
	Оценка:

	От:	Evgeny.Panasyuk
	Дата:	06.03.13 08:46
	Оценка: