Compile-time strlen - C/C++

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

...

__>Вы плохого мнения о компиляторах.
__>Компилятор умеет оптимизировать эту вещь и не делать настоящего копирования.

__>

__>    const char a[] = "aaa";
__>004113BE A1 3C 57 41 00   mov         eax,dword ptr [string "aaa" (41573Ch)] 
__>004113C3 89 45 F8         mov         dword ptr [a],eax 
__>

; Function compile flags: /Ogtpy
; COMDAT _wmain

...

; 14 : const char a[]="34bfc3xnw3xheirxfb846xtb4n8xg54xngf54r";

mov ecx, 9
mov esi, OFFSET ??_C@_0CH@DJLFEJFA@34bfc3xnw3xheirxfb846xtb4n8xg54x@
lea edi, DWORD PTR _a$[esp+52]
rep movsd

Я бы сказал, что я разумного о них мнения, и предпочел бы не расчитывать лишний раз на них. Это стандартные Release настройки VS2K5SP1.

Более того, если бы Вы внимательно посмотрели на код, который сами же привели, то увидели бы, что копирование происходило, просто такой Вы подобрали пример, что скопировать надо 4 байта — 3 'a' и завершающий 0. Что как раз влезает в DWORD, который и скопировался.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

L>Это? Спасибо.

Да. Всегда пожалуйста

Для "спасибо" есть кнопки

Все эмоциональные формулировки не соотвествуют действительному положению вещей и приведены мной исключительно "ради красного словца". За корректными формулировками и неискажённым изложением идей, следует обращаться к их автором или воспользоваться поиском

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

L>Есть ли какой-нибудь класс, служащий оберткой для строковых литералов.

L>Что-нибудь в духе

L>

L>std::string s="Hello";
L>f(s.c_str(),s.size());
L>

L>Только в первой строке произойдет копирование в буфер. Хотелось бы этого по возможности избежать. А во второй избежать вызова strlen или совсем, или хотя бы многократного.

L>Если есть 2 класса, один из которых, скажем ограничивает интерфейс только константными методами, а второй копирует в буфер только по необходимости, то совсем замечательно было бы.

void f (const char* ptr, int sz) {}

template<int N>
void f(const char (&arr)[N])
{
   return f(arr, N-1);
}


int main()
{
   f("Hello");
   return 0;
}

MS>>Тут std::string не нужен:

MS>>

MS>>f("Hello",sizeof("Hello")-1);
MS>>

L>Хм, как насчет того, что дублируются строки? А если они длинные?

#define STR_HELLO "Hello"
или
static const char STR_HELLO[] = "Hello";

f( STR_HELLO, sizeof(STR_HELLO)-1 );

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

L>>>Хм, как насчет того, что дублируются строки? А если они длинные?
LD>Нефига они не дублируются, sizeof() вычисляется на этапе компиляции, это не вызов функции.

Два строковых литерала запросто могут дважды оказаться в бинарнике. От компилятора, в общем, зависит. У VC опцией рулится.

Есть ли какой-нибудь класс, служащий оберткой для строковых литералов.

Что-нибудь в духе

std::string s="Hello";
f(s.c_str(),s.size());

Только в первой строке произойдет копирование в буфер. Хотелось бы этого по возможности избежать. А во второй избежать вызова strlen или совсем, или хотя бы многократного.

Если есть 2 класса, один из которых, скажем ограничивает интерфейс только константными методами, а второй копирует в буфер только по необходимости, то совсем замечательно было бы.

L>Есть ли какой-нибудь класс, служащий оберткой для строковых литералов.

L>Что-нибудь в духе

L>

L>std::string s="Hello";
L>f(s.c_str(),s.size());
L>

Тут std::string не нужен:

f("Hello",sizeof("Hello")-1);

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

L>>Есть ли какой-нибудь класс, служащий оберткой для строковых литералов.

L>>Что-нибудь в духе

L>>

L>>std::string s="Hello";
L>>f(s.c_str(),s.size());
L>>

MS>Тут std::string не нужен:

MS>

MS>f("Hello",sizeof("Hello")-1);
MS>

Хм, как насчет того, что дублируются строки? А если они длинные?

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

...

B>

B>void f (const char* ptr, int sz) {}

B>template<int N>
B>void f(const char (&arr)[N])
B>{
B>   return f(arr, N-1);
B>}


B>int main()
B>{
B>   f("Hello");
B>   return 0;
B>}
B>

Так это к каждой функции нужно писать обертку. Хотя явно лучше варианта MShura. А всё таки легковесного класса нет?

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

B>>

B>>void f (const char* ptr, int sz) {}

B>>template<int N>
B>>void f(const char (&arr)[N])
B>>{
B>>   return f(arr, N-1);
B>>}


B>>int main()
B>>{
B>>   f("Hello");
B>>   return 0;
B>>}
B>>

L>Так это к каждой функции нужно писать обертку. Хотя явно лучше варианта MShura. А всё таки легковесного класса нет?
как вариант:

template<typename T, int len>
int str_len_ct(const T (&)[len])
{
   return len-1;
}

int main(int argc, const char * argv[])
{
   int len = str_len_ct("Hello");
   int len2 = str_len_ct(L"unicode");
}

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

Тьфу, не то запостил:

void f (const char* ptr, int sz) {}
void f (const wchar_t* ptr, int sz) {}

static const char str1[] = "Hello";
static const wchar_t str2[] = L"Unicode";

template<typename T, int len>
int str_len_ct(const T (&)[len])
{
   return len-1;
}

int main(int argc, const char * argv[])
{
    f(str1,str_len_ct(str1));
    f(str2,str_len_ct(str2));
}

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

...

L>>Так это к каждой функции нужно писать обертку. Хотя явно лучше варианта MShura. А всё таки легковесного класса нет?
C>как вариант:

C>template<typename T, int len>
C>int str_len_ct(const T (&)[len])
C>{
C>   return len-1;
C>}

C>int main(int argc, const char * argv[])
C>{
C>   int len = str_len_ct("Hello");
C>   int len2 = str_len_ct(L"unicode");
C>}

А чего-нибудь похожего на

template<typename T, int len>
class StringLiteral
{
...
public:
    StringLiteral(const T (&b)[l])
    {
        buf=b;
        len=l;
    }
    size_t size()
    {
        return len;
    }
    const T* c_str()
    {
        return buf;
    }
}

И более-менее стандартного при этом нет?

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

L>

L>std::string s="Hello";
L>f(s.c_str(),s.size());
L>

Ну напиши

Скажем так как-то:

class constStr {
public:
    template<int N>
    constStr( const char (&str)[N] ) : ptr( str ), count( N ) {}

    operator const char*() const { return ptr; };
    int size() const { return count; }

    // тут добавь интерфейса по вкусу...
private:
    char const * const ptr;
    const int count;
};

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

C>static const char str1[] = "Hello";
C>static const wchar_t str2[] = L"Unicode";

А вот в этом месте копирования при инициализации не будет? VS, вроде, скопирует из той области, где лежит Hello, например, в str1.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

...

E>Ну напиши

E>Скажем так как-то:

E>

class constStr {
E>public:
E>    template<int N>
E>    constStr( const char (&str)[N] ) : ptr( str ), count( N ) {}

E>    operator const char*() const { return ptr; };
E>    int size() const { return count; }

E>    // тут добавь интерфейса по вкусу...
E>private:
E>    char const * const ptr;
E>    const int count;
E>};

Re[4]: Compile-time strlen Написать-то можно, но как известно, всё украдено до нас.

Может кто уже сделал такое.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

L>Только в первой строке произойдет копирование в буфер. Хотелось бы этого по возможности избежать. А во второй избежать вызова strlen или совсем, или хотя бы многократного.

L>Если есть 2 класса, один из которых, скажем ограничивает интерфейс только константными методами, а второй копирует в буфер только по необходимости, то совсем замечательно было бы.

Может имеет смысл посмотреть в сторону const_string ?

[RSDN@Home 1.2.0 alpha rev. 775 on Windows XP 5.1.2600.131072]

"В любое мгновение принятия решения, лучшее, что вы можете сделать, это принять правильное решение; следующим лучшим вариантом будет принять неправильное решение, худший вариант – не принимать решения совсем" (c) Теодор Рузвельт.

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

L>А чего-нибудь похожего на

L>

L>template<typename T, int len>
L>class StringLiteral
L>{
L>...
L>public:
L>    StringLiteral(const T (&b)[l])
L>    {
L>        buf=b;
L>        len=l;
L>    }
L>    size_t size()
L>    {
L>        return len;
L>    }
L>    const T* c_str()
L>    {
L>        return buf;
L>    }
L>}
L>

L>И более-менее стандартного при этом нет?
Имхо нет, да и работать это будет только со статически константными строками, определенными в этом же модуле.

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

B>

B>void f (const char* ptr, int sz) {}

B>template<int N>
B>void f(const char (&arr)[N])
B>{
B>   return f(arr, N-1);
B>}

B>

Вопрос почти по теме.
Почему такой код работает:

template<typename T, size_t t_n>
inline size_t arr_size(const T (&)[t_n]){
    return t_n;
}

А такой не работает:

template<typename T, size_t t_n>
inline size_t arr_size(const T [t_n]){
    return t_n;
}
.........
.........
int  arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
cout << arr_size(arr) << endl;
.........

error C2784: 'size_t arr_size(const T [t_n])' : could not deduce template argument for 'const T [t_n]' from 'int [12]'
(VS2005)

?

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

...

C>Имхо нет, да и работать это будет только со статически константными строками, определенными в этом же модуле.

Так больше ничего и не надо. Просто думал, что может уже есть что-то похожее.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Bell, Вы писали:
А>error C2784: 'size_t arr_size(const T [t_n])' : could not deduce template argument for 'const T [t_n]' from 'int [12]'
А>(VS2005)

А>?

Потому, что f( T t[] ), f( T t[12] ) и f( T* const t ) эквивалентны. Так что вывести длину массива действительно никак не получится.

Хинт: как передавать массив по значению собираешься?

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

E>Потому, что f( T t[] ), f( T t[12] ) и f( T* const t ) эквивалентны. Так что вывести длину массива действительно никак не получится.
E>Хинт: как передавать массив по значению собираешься?

Во блин. Прикольный язык, ИМХО его невозможно выучить до конца — пока выучишь, новый стандарт приймут

Я знал, что f( T t[] ) эквивалентно f( T* const t ),
но как-то не подумал что f( T t[X] ) == f( T t[Y] ) == f( T t[] ) == f( T* const t ).
Спасибо.

L>std::string s="Hello";
L>f(s.c_str(),s.size());
L>

Поиск по форуму ?
http://www.rsdn.ru/forum/message/2295069.1.aspx
http://www.rsdn.ru/forum/message/2186167.1.aspx

L>Только в первой строке произойдет копирование в буфер. Хотелось бы этого по возможности избежать. А во второй избежать вызова strlen или совсем, или хотя бы многократного.

L>Если есть 2 класса, один из которых, скажем ограничивает интерфейс только константными методами, а второй копирует в буфер только по необходимости, то совсем замечательно было бы.

Насчет копирование решается просто: Boost.Range (Поиск по форуму помогает

)

typedef boost::iterator_range<char> char_range;

void f(char_range p)
{
}

std::string my_str("aa"); // Copy
f(make_iterator_range(my_str));

char const my_array[] = "aa";
f(make_iterator_range(my_array)); // No copy

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

__>Насчет копирование решается просто: Boost.Range (Поиск по форуму помогает

)

__>

__>typedef boost::iterator_range<char> char_range;

__>void f(char_range p)
__>{
__>}

__>std::string my_str("aa"); // Copy
__>f(make_iterator_range(my_str));

__>char const my_array[] = "aa";  //Copy
__>f(make_iterator_range(my_array)); // No copy
__>

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

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

__>>Насчет копирование решается просто: Boost.Range (Поиск по форуму помогает

)

__>>

__>>typedef boost::iterator_range<char> char_range;

__>>void f(char_range p)
__>>{
__>>}

__>>std::string my_str("aa"); // Copy
__>>f(make_iterator_range(my_str));

__>>char const my_array[] = "aa";  //Copy
__>>f(make_iterator_range(my_array)); // No copy
__>>

Вы плохого мнения о компиляторах.
Компилятор умеет оптимизировать эту вещь и не делать настоящего копирования.

    const char a[] = "aaa";
004113BE A1 3C 57 41 00   mov         eax,dword ptr [string "aaa" (41573Ch)] 
004113C3 89 45 F8         mov         dword ptr [a],eax

Здравствуйте, Аноним, Вы писали:

А>Во блин. Прикольный язык, ИМХО его невозможно выучить до конца — пока выучишь, новый стандарт приймут

За похвалу конечно спасибо, но это всё-таки заблуждение. ИМХО можно довольно глубоко

Ну да это просто комитет нас щадит

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

L>Re[4]: Compile-time strlen Написать-то можно, но как известно, всё украдено до нас.

Может кто уже сделал такое.

Ну ct-strlen можно много как написать. Только объект иметь таки удобнее. Его же копировать там можно, begin end приделать и всё такое...

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

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

L>>Только в первой строке произойдет копирование в буфер. Хотелось бы этого по возможности избежать. А во второй избежать вызова strlen или совсем, или хотя бы многократного.

L>>Если есть 2 класса, один из которых, скажем ограничивает интерфейс только константными методами, а второй копирует в буфер только по необходимости, то совсем замечательно было бы.

N>Может имеет смысл посмотреть в сторону const_string ?

Спасибо большое, скачал, разбираюсь. Буду профилировать с этими строками.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

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

L>>Re[4]: Compile-time strlen Написать-то можно, но как известно, всё украдено до нас.

Может кто уже сделал такое.

E>Ну ct-strlen можно много как написать. Только объект иметь таки удобнее. Его же копировать там можно, begin end приделать и всё такое...

Так никто не спорит, тем более не сильно и отличаются Ваш class constStr от моего template<typename T, int len> class StringLiteral.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

L>Так никто не спорит, тем более не сильно и отличаются Ваш class constStr от моего template<typename T, int len> class StringLiteral.

Принципиально отличается. У меня тип объекта не зависит от его значения...

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

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

L>>Так никто не спорит, тем более не сильно и отличаются Ваш class constStr от моего template<typename T, int len> class StringLiteral.

E>Принципиально отличается. У меня тип объекта не зависит от его значения...

template<typename T>
class StringLiteral
{
...
public:
    template<size_t l>
    StringLiteral(const T (&b)[l])
    {
        buf=b;
        len=l;
    }
    size_t size()
    {
        return len;
    }
    const T* c_str()
    {
        return buf;
    }
}

Это? Спасибо.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

L>Более того, если бы Вы внимательно посмотрели на код, который сами же привели, то увидели бы, что копирование происходило, просто такой Вы подобрали пример, что скопировать надо 4 байта — 3 'a' и завершающий 0. Что как раз влезает в DWORD, который и скопировался.

Решение которое, надеюсь, вас устроит в ветке уже предложили.
Можно вариацию вроде:

#include <boost/tuple/tuple.hpp>

template<typename T, size_t N>
boost::tuple<T const*, size_t> static_length(T const (&a)[N])
{
 return boost::tuple<T const*, size_t>(a, N);
}

boost::tuple<char const*, size_t> x(static_length("abcd"));

__>>Вы плохого мнения о компиляторах.
__>>Компилятор умеет оптимизировать эту вещь и не делать настоящего копирования.

...
L>Я бы сказал, что я разумного о них мнения, и предпочел бы не расчитывать лишний раз на них. Это стандартные Release настройки VS2K5SP1.
...

Чтобы помочь компилятору в его сложной работе достаточно сделать выражение const char a[] = "aaa"; глобальным.
Никаких дополнительных расходов, один недостаток — область видимости вся единица трансляции.

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

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

L>>Более того, если бы Вы внимательно посмотрели на код, который сами же привели, то увидели бы, что копирование происходило, просто такой Вы подобрали пример, что скопировать надо 4 байта — 3 'a' и завершающий 0. Что как раз влезает в DWORD, который и скопировался.

__>Решение которое, надеюсь, вас устроит в ветке уже предложили.

Предложили даже 2 решения, сейчас занимался проверкой, что лучше по скорости. Проблема в том, что в некотором legacy коде, производительности которого не хватает на имеющемся железе буквально чуть-чуть, во внутренних циклах порядочно вызовов strlen от строковых литералов. Естественно, что появилась мысль их убрать за ненадобностью. Искался самый простой вариант.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

MS>Чтобы помочь компилятору в его сложной работе достаточно сделать выражение const char a[] = "aaa"; глобальным.
MS>Никаких дополнительных расходов, один недостаток — область видимости вся единица трансляции.

Не то, чтобы это сильно мешало. В конце-концов, если пересекутся 2 одинаковых объекта, построенных на одинаковых строковых литералах, то можно оставить любой из них, но не вижу смысла так глобально модифицировать код, да и для использования make_iterator_range необходимо, как минимум, написать заглушки к каждой используемой функции.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

L>>Хм, как насчет того, что дублируются строки? А если они длинные?
Нефига они не дублируются, sizeof() вычисляется на этапе компиляции, это не вызов функции.

MS>#define STR_HELLO "Hello"
После обработки препроцессором это даст тотже самый sizeof("Hello")

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

L>>>Хм, как насчет того, что дублируются строки? А если они длинные?
LD>Нефига они не дублируются, sizeof() вычисляется на этапе компиляции, это не вызов функции.

Строки дублируются в исходном коде. Что иногда приводит к неприятным ошибкам.

...

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

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

L>>>>Хм, как насчет того, что дублируются строки? А если они длинные?
LD>>Нефига они не дублируются, sizeof() вычисляется на этапе компиляции, это не вызов функции.

S>Два строковых литерала запросто могут дважды оказаться в бинарнике. От компилятора, в общем, зависит. У VC опцией рулится.

Кстати, а зачем интересно могут понадобится 2 одинаковые строки в бинарнике? Ну, что проще спихать туда все, не сортируя, это понятно.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

L>Кстати, а зачем интересно могут понадобится 2 одинаковые строки в бинарнике? Ну, что проще спихать туда все, не сортируя, это понятно.

Тяжкое наследие С

L>>>Хм, как насчет того, что дублируются строки? А если они длинные?
LD>Нефига они не дублируются, sizeof() вычисляется на этапе компиляции, это не вызов функции.

MS>>#define STR_HELLO "Hello"
LD>После обработки препроцессором это даст тотже самый sizeof("Hello")

Приведенное решение упрощало работу с длинными запись

f( "VeryLongVeryLongVeryLongVeryLongVeryLongVeryLongString", sizeof("VeryLongVeryLongVeryLongVeryLongVeryLongVeryLongString")-1 );

до такой

#define STR_HELLO "VeryLongVeryLongVeryLongVeryLongVeryLongVeryLongString"
f( STR_HELLO, sizeof(STR_HELLO)-1 );

По сгенеренному коду два примера будут одинаковые
Никакого лишнего overhead'а ни при каких опциях компиляции.

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

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

L>>Кстати, а зачем интересно могут понадобится 2 одинаковые строки в бинарнике? Ну, что проще спихать туда все, не сортируя, это понятно.

E>Тяжкое наследие С

А поподробней в этом месте, пожалуйста.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

...

MS>Приведенное решение упрощало работу с длинными запись
MS>

MS>f( "VeryLongVeryLongVeryLongVeryLongVeryLongVeryLongString", sizeof("VeryLongVeryLongVeryLongVeryLongVeryLongVeryLongString")-1 );
MS>

MS>до такой
MS>

MS>#define STR_HELLO "VeryLongVeryLongVeryLongVeryLongVeryLongVeryLongString"
MS>f( STR_HELLO, sizeof(STR_HELLO)-1 );
MS>

MS>По сгенеренному коду два примера будут одинаковые
MS>Никакого лишнего overhead'а ни при каких опциях компиляции.

Даже если там будет короткая строка, то второй подход предпочтительней, чтобы избежать f("hello",sizeof("helo")) или чего-то в этом роде.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

L>А поподробней в этом месте, пожалуйста.
Ну когда-то можно было полазать грязными лапами внутри литерала...

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

L>>>Хм, как насчет того, что дублируются строки? А если они длинные?
LD>Нефига они не дублируются, sizeof() вычисляется на этапе компиляции, это не вызов функции.
Вы о чем? Кто с этим спорит?

MS>>#define STR_HELLO "Hello"
LD>После обработки препроцессором это даст тотже самый sizeof("Hello")
Что Вы хотели этим сказать

и к чему?

	От:	lifrsdn
	Дата:	30.11.07 15:05
	Оценка:	+2

	От:	Erop
	Дата:	30.11.07 17:33
	Оценка:	2 (1)

	От:	Bell
	Дата:	29.11.07 11:25
	Оценка:	1 (1)

	От:	MShura
	Дата:	29.11.07 12:24
	Оценка:	-1

	От:	Sergey
	Дата:	30.11.07 21:38
	Оценка: